├── .DS_Store ├── Architecture ├── README.md ├── docker-architecture.jpeg ├── docker-architecture.png └── virtual-machine-architecture.jpeg ├── CI ├── .DS_Store ├── 1.png ├── 2.png ├── 3.png ├── 4.png ├── 5.png ├── 6.png ├── 7.png └── README.md ├── Cloud ├── .DS_Store ├── 1.png ├── 10.png ├── 11.png ├── 12.png ├── 13.png ├── 14.png ├── 15.png ├── 16.png ├── 17.png ├── 18.png ├── 19.png ├── 2.png ├── 20.png ├── 21.png ├── 3.png ├── 4.png ├── 5.png ├── 6.png ├── 7.png ├── 8.png ├── 9.png ├── README.md └── basic_interface.jpeg ├── Compose ├── .DS_Store ├── README.md ├── compose_file.jpeg └── docker_compose_installation.jpeg ├── Construction-fichiers ├── Dockerfile ├── README.md └── docker-build.png ├── Container-hosts ├── README.md ├── linuxcontainers.png ├── windowscontainer.png └── windowshypercontainer.png ├── Containers-Shells ├── README.md └── web-page.png ├── Containers ├── .DS_Store ├── README.md ├── containers.jpeg ├── docker-cheat-heet.png └── runcommand.png ├── File └── README.md ├── Gestion-ports ├── README.md ├── inspect.png ├── pull.png └── webpage.png ├── Hub └── README.md ├── Images ├── .DS_Store ├── README.md ├── docker-flow.png └── dockerimages.png ├── Installation ├── README.md └── containers.jpeg ├── Kubernetes └── README.md ├── KubernetesArchitecture ├── .DS_Store ├── README.md └── kubernetes_architecture.jpeg ├── LICENSE ├── Linking └── README.md ├── Logging └── README.md ├── Networking ├── .DS_Store ├── Macvlan.png ├── README.md ├── docker-overlay.png ├── inspect.png └── networklist.png ├── Pratiques ├── README.md ├── lifecycle.png └── stats.png ├── Private-registers ├── README.md ├── newreg.png └── ps.png ├── Public-Repo ├── README.md └── repo.png ├── README.md ├── Storage ├── .DS_Store ├── README.md ├── info.png ├── table.png ├── tmp.txt └── volumelist.png ├── WebServer ├── Dockerfile ├── README.md └── webpage.png ├── _config.yml └── docker-logo.png /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/.DS_Store -------------------------------------------------------------------------------- /Architecture/README.md: -------------------------------------------------------------------------------- 1 | # Architecture 2 | 3 | ![](docker-architecture.png) 4 | 5 | ## Comparing Virtual Machines vs Docker Containers: 6 | La première chose que vous devez savoir est que les conteneurs Docker ne sont pas des machines virtuelles. 7 | 8 | En 2014, lorsque j'ai découvert le concept de conteneurs Docker, je les ai décrits comme des types de machines virtuelles légères ou allégées. 9 | 10 | Cela semblait plutôt cool sur le papier et la comparaison était logique, car le marketing initial de Docker s’appuyait beaucoup sur elle, car elle utilisait moins de mémoire et démarrait beaucoup plus rapidement que les machines virtuelles. 11 | 12 | Ils ont continué à lancer des phrases telles que «contrairement à un ordinateur virtuel qui démarre en quelques minutes, les conteneurs Docker démarrent dans environ 50 millisecondes» et partout où j'ai regardé, il y avait des comparaisons avec des ordinateurs virtuels. 13 | 14 | Donc, encore une fois… Les conteneurs Docker ne sont pas des ordinateurs virtuels, mais nous allons les comparer. 15 | 16 | ### Comprendre les machines virtuelles 17 | 18 | ![](virtual-machine-architecture.jpeg) 19 | 20 | Définissons maintenant ces couches de bas en haut: 21 | 22 | * Tout commence par une sorte d'infrastructure. Il peut s’agir de votre ordinateur portable, d’un serveur dédié fonctionnant dans un centre de données ou d’un serveur privé virtuel que vous utilisez dans le nuage, tel que DigitalOcean ou une instance Amazon EC2. 23 | 24 | * En plus de cet hôte exécute un système d'exploitation. Sur votre ordinateur portable, ce sera probablement MacOS, Windows ou une distribution de Linux. Lorsque nous parlons de machines virtuelles, il s’agit généralement du système d’exploitation hôte. 25 | 26 | * Ensuite, nous avons une chose appelée un hyperviseur. Vous pouvez considérer les machines virtuelles comme un ordinateur autonome regroupé dans un fichier unique, mais vous devez être en mesure d'exécuter ce fichier. Les hyperviseurs de type 1 courants sont HyperKit pour MacOS, Hyper-V pour Windows et KVM pour Linux. Les hyperviseurs de type 2 populaires sont VirtualBox et VMWare. C’est tout ce que vous devez savoir pour le moment. 27 | 28 | * La couche suivante de ce délicieux serveur contient vos systèmes d’exploitation invités. Supposons que vous vouliez exécuter 3 applications sur votre serveur en isolation totale. Cela nécessiterait de lancer 3 systèmes d'exploitation invités, tous contrôlés par votre hyperviseur. 29 | 30 | * Les machines virtuelles sont livrées avec beaucoup de bagages. Chaque système d'exploitation invité peut atteindre 700 Mo. 31 | 32 | * Cela signifie que vous utilisez 2,1 Gb d’espace disque uniquement pour vos systèmes d’exploitation invités. La situation empire car chaque SE invité a également besoin de ses propres ressources en processeur et en mémoire. 33 | 34 | * De plus, chaque SE invité a besoin de sa propre copie de divers fichiers binaires et bibliothèques pour permettre à l’application de fonctionner. Par exemple, vous devrez peut-être installer libpq-dev pour que la bibliothèque de votre application Web permettant la connexion à PostgreSQL puisse se connecter à votre base de données PostgreSQL. 35 | Si vous utilisez quelque chose comme Ruby, vous devez installer vos gemmes. De même avec Python ou NodeJS, vous installeriez vos paquets. À peu près tous les principaux langages de programmation ont leur propre gestionnaire de paquets, vous voyez l'idée. 36 | Étant donné que chaque application est différente, il est prévu que chaque application aura son propre ensemble d'exigences de bibliothèque. 37 | 38 | * Enfin, nous avons notre application. C’est le code source de l’application géniale que vous avez construite. Si vous souhaitez que chaque application soit isolée, vous devez les exécuter dans son propre système d'exploitation invité. 39 | 40 | ### Comprendre les conteneurs Docker: 41 | Voici à quoi ressemble la même configuration avec les conteneurs Docker: 42 | 43 | ![](docker-architecture.jpeg) 44 | 45 | * Les conteneurs Docker ne sont pas des balles magiques. Nous avons encore besoin d'une sorte d'infrastructure pour les faire fonctionner. Comme les ordinateurs virtuels, cela pourrait être votre ordinateur portable ou un serveur quelque part dans le cloud. 46 | 47 | * Ensuite, nous avons notre système d'exploitation hôte. Cela pourrait être tout ce que vous voulez capable de faire fonctionner Docker. Toutes les principales distributions de Linux sont prises en charge et il existe également des moyens d’exécuter Docker sous MacOS et Windows. 48 | 49 | * Ah, enfin quelque chose de nouveau. Le démon Docker remplace l'hyperviseur. Le démon Docker est un service qui s'exécute en arrière-plan sur votre système d'exploitation hôte et gère tout ce qui est nécessaire pour exécuter et interagir avec les conteneurs Docker. 50 | 51 | * Ensuite, nous avons nos fichiers binaires et nos bibliothèques, comme nous le faisons sur les machines virtuelles. Au lieu d’être exécutées sur un système d’exploitation invité, elles sont intégrées à des packages spéciaux appelés images Docker. Ensuite, le démon Docker exécute ces images. 52 | 53 | * La dernière pièce du puzzle est nos applications. Chacune d'elles résiderait dans sa propre image Docker et serait gérée indépendamment par le démon Docker. En règle générale, chaque application et ses dépendances de bibliothèque sont regroupées dans la même image Docker. Comme vous pouvez le constater, chaque application est toujours isolée. 54 | 55 | ### Différences dans le monde réel entre les deux technologies: 56 | 57 | Au cas où vous ne le remarqueriez pas, Docker contient beaucoup moins de pièces en mouvement. Nous n’avons besoin d’exécuter aucun type d’hyperviseur ou de machine virtuelle. 58 | 59 | Au lieu de cela, le démon Docker communique directement avec le système d'exploitation hôte et sait comment rationner les ressources pour les conteneurs Docker en cours d'exécution. C’est également un expert en matière d’assurance que chaque conteneur est isolé du système d’exploitation hôte et des autres conteneurs. 60 | 61 | La différence du monde réel signifie ici qu'au lieu d'attendre une minute le démarrage d'une machine virtuelle, vous pouvez démarrer un conteneur de menu fixe en quelques millisecondes. 62 | 63 | Vous économisez également une tonne d'espace disque et d'autres ressources système car vous n'avez pas besoin de trimballer un système d'exploitation invité volumineux pour chaque application que vous exécutez. De plus, Docker n’a pas besoin de virtualisation, car il s’exécute directement sur le système d’exploitation hôte. 64 | 65 | Cela dit, ne laissez pas cet article vous donner votre opinion sur les machines virtuelles. Les deux machines virtuelles et Docker ont des cas d'utilisation différents à mon avis. 66 | 67 | Les machines virtuelles sont très efficaces pour isoler les ressources système et des environnements de travail entiers. Par exemple, si vous êtes propriétaire d'une société d'hébergement Web, vous utiliserez probablement des machines virtuelles pour séparer chaque client. 68 | 69 | En revanche, la philosophie de Docker est d’isoler les applications individuelles et non les systèmes entiers. Un exemple parfait serait de scinder un ensemble de services d’application Web en leurs propres images Docker. -------------------------------------------------------------------------------- /Architecture/docker-architecture.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Architecture/docker-architecture.jpeg -------------------------------------------------------------------------------- /Architecture/docker-architecture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Architecture/docker-architecture.png -------------------------------------------------------------------------------- /Architecture/virtual-machine-architecture.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Architecture/virtual-machine-architecture.jpeg -------------------------------------------------------------------------------- /CI/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/CI/.DS_Store -------------------------------------------------------------------------------- /CI/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/CI/1.png -------------------------------------------------------------------------------- /CI/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/CI/2.png -------------------------------------------------------------------------------- /CI/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/CI/3.png -------------------------------------------------------------------------------- /CI/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/CI/4.png -------------------------------------------------------------------------------- /CI/5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/CI/5.png -------------------------------------------------------------------------------- /CI/6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/CI/6.png -------------------------------------------------------------------------------- /CI/7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/CI/7.png -------------------------------------------------------------------------------- /CI/README.md: -------------------------------------------------------------------------------- 1 | # Intégration continue 2 | 3 | Docker est intégré à de nombreux outils d’intégration continue, qui incluent également le célèbre outil CI appelé Jenkins. Dans Jenkins, vous avez des plugins disponibles qui peuvent être utilisés pour travailler avec des conteneurs. Voyons donc rapidement un plugin Docker disponible pour l’outil Jenkins. 4 | 5 | Voyons étape par étape ce qui est disponible dans Jenkins pour les conteneurs Docker. 6 | 7 | ## Étape 1 8 | Accédez au tableau de bord Jenkins et cliquez sur Gérer Jenkins. 9 | 10 | ![](1.png) 11 | 12 | ## Étape 2 13 | Allez à gérer les plugins. 14 | 15 | ![](2.png) 16 | 17 | ## Étape 3 18 | Recherchez les plugins Docker. Choisissez le plugin Docker et cliquez sur le bouton Installer sans redémarrer. 19 | 20 | ![](3.png) 21 | 22 | ## Étape 4 23 | Une fois l'installation terminée, accédez à votre travail dans le tableau de bord Jenkins. Dans notre exemple, nous avons un travail appelé Demo. 24 | 25 | ![](4.png) 26 | 27 | ## Étape 5 28 | Dans le travail, lorsque vous passez à l’étape Générer, vous pouvez maintenant voir l’option permettant de démarrer et d’arrêter les conteneurs. 29 | 30 | ![](5.png) 31 | 32 | ## Étape 6 33 | À titre d’exemple simple, vous pouvez choisir l’option supplémentaire permettant d’arrêter les conteneurs une fois la construction terminée. Ensuite, cliquez sur le bouton Enregistrer. 34 | 35 | ![](6.png) 36 | 37 | Maintenant, lancez votre travail à Jenkins. Dans la sortie de la console, vous pourrez maintenant voir que la commande Arrêter tous les conteneurs a été exécutée. 38 | 39 | ![](7.png) 40 | 41 | -------------------------------------------------------------------------------- /Cloud/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/.DS_Store -------------------------------------------------------------------------------- /Cloud/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/1.png -------------------------------------------------------------------------------- /Cloud/10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/10.png -------------------------------------------------------------------------------- /Cloud/11.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/11.png -------------------------------------------------------------------------------- /Cloud/12.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/12.png -------------------------------------------------------------------------------- /Cloud/13.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/13.png -------------------------------------------------------------------------------- /Cloud/14.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/14.png -------------------------------------------------------------------------------- /Cloud/15.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/15.png -------------------------------------------------------------------------------- /Cloud/16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/16.png -------------------------------------------------------------------------------- /Cloud/17.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/17.png -------------------------------------------------------------------------------- /Cloud/18.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/18.png -------------------------------------------------------------------------------- /Cloud/19.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/19.png -------------------------------------------------------------------------------- /Cloud/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/2.png -------------------------------------------------------------------------------- /Cloud/20.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/20.png -------------------------------------------------------------------------------- /Cloud/21.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/21.png -------------------------------------------------------------------------------- /Cloud/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/3.png -------------------------------------------------------------------------------- /Cloud/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/4.png -------------------------------------------------------------------------------- /Cloud/5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/5.png -------------------------------------------------------------------------------- /Cloud/6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/6.png -------------------------------------------------------------------------------- /Cloud/7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/7.png -------------------------------------------------------------------------------- /Cloud/8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/8.png -------------------------------------------------------------------------------- /Cloud/9.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/9.png -------------------------------------------------------------------------------- /Cloud/README.md: -------------------------------------------------------------------------------- 1 | # Cloud 2 | 3 | Le Cloud Docker est un service fourni par Docker dans lequel vous pouvez effectuer les opérations suivantes: 4 | * Nœuds - Vous pouvez connecter le cloud Docker à vos fournisseurs de cloud existants, tels qu'Azure et AWS, pour créer des conteneurs sur ces environnements. 5 | * Cloud Repository - Fournit un endroit où vous pouvez stocker vos propres référentiels. 6 | * Intégration continue - Connectez-vous à Github et créez un pipeline d’intégration continue. 7 | * Déploiement d'applications - Déployez et mettez à l'échelle l'infrastructure et les conteneurs. 8 | * Déploiement continu - Peut automatiser les déploiements. 9 | 10 | ## Commencer 11 | Vous pouvez vous rendre sur le lien suivant pour commencer à utiliser Docker Cloud: https://cloud.docker.com/ 12 | Une fois connecté, l'interface de base suivante vous sera fournie 13 | 14 | ![](basic_interface.jpeg) 15 | 16 | ## Connexion au fournisseur de cloud 17 | 18 | La première étape consiste à vous connecter à un fournisseur de cloud existant. Les étapes suivantes vous montreront comment se connecter à un fournisseur Amazon Cloud. 19 | 20 | ### Étape 1 21 | La première étape consiste à vérifier que vous disposez des bonnes clés AWS. Cela peut être pris à partir de la console aws. Connectez-vous à votre compte aws en utilisant le lien suivant: https://aws.amazon.com/console/ 22 | 23 | ![](1.png) 24 | 25 | ### Étape 2 26 | Une fois connecté, accédez à la section Informations d'identification de sécurité. Notez les clés d’accès qui seront utilisées à partir de Docker Hub. 27 | 28 | ![](2.png) 29 | 30 | ![](3.png) 31 | 32 | ### Étape 3 33 | Ensuite, vous devez créer une stratégie dans aws qui permettra à Docker de visualiser les instances EC2. Accédez à la section des profils dans aws. Cliquez sur le bouton Créer une politique. 34 | 35 | ![](4.png) 36 | 37 | ### Étape 4 38 | Cliquez sur ‘Créer votre propre stratégie’ et attribuez-lui le nom de stratégie dockercloudpolicy et la définition de la stratégie comme indiqué ci-dessous. 39 | ```sh 40 | { 41 | "Version": "2012-10-17", 42 | "Statement": [ { 43 | "Action": [ 44 | "ec2:*", 45 | "iam:ListInstanceProfiles" 46 | ], 47 | "Effect": "Allow", 48 | "Resource": "*" 49 | } ] 50 | } 51 | ``` 52 | ![](5.png) 53 | 54 | ### Étape 5 55 | Ensuite, vous devez créer un rôle qui sera utilisé par Docker pour créer des nœuds sur AWS. Pour cela, accédez à la section Rôles dans AWS et cliquez sur l'option Créer un nouveau rôle. 56 | 57 | ![](6.png) 58 | 59 | ### Étape 6 60 | Nommez le rôle dockercloud-role 61 | 62 | ![](7.png) 63 | 64 | ### Étape 7 65 | Sur l’écran suivant, allez à "Rôle pour accès entre comptes" et sélectionnez "Fournir un accès entre votre compte et un compte AWS tiers". 66 | 67 | ![](8.png) 68 | 69 | ### Étape 8 70 | Sur l’écran suivant, entrez les détails suivants: 71 | * Dans le champ ID du compte, entrez l'ID du service Docker Cloud: 689684103426. 72 | * Dans le champ External ID, entrez votre nom d'utilisateur Docker Cloud. 73 | 74 | ![](9.png) 75 | 76 | ### Étape 9 77 | Ensuite, cliquez sur le bouton Étape suivante et, dans l'écran suivant, joignez la stratégie créée à l'étape précédente. 78 | 79 | ![](10.png) 80 | 81 | ### Étape 10 82 | Enfin, sur le dernier écran lors de la création du rôle, veillez à copier le rôle créé. 83 | ```sh 84 | arn:aws:iam::085363624145:role/dockercloud-role 85 | ``` 86 | 87 | ![](11.png) 88 | 89 | ### Étape 11 90 | Revenez maintenant à Docker Cloud, sélectionnez Fournisseurs de cloud, puis cliquez sur le symbole de prise en regard d'Amazon Web Services. 91 | 92 | ![](12.png) 93 | 94 | Entrez le rôle et cliquez sur le bouton Enregistrer. 95 | 96 | ![](13.png) 97 | 98 | Une fois enregistrée, l'intégration avec AWS serait terminée. 99 | 100 | ![](14.png) 101 | 102 | ## Configuration des nœuds 103 | Une fois l'intégration avec AWS terminée, l'étape suivante consiste à configurer un nœud. Accédez à la section Nœuds dans Docker Cloud. Notez que la configuration des nœuds configure automatiquement un cluster de nœuds en premier. 104 | 105 | ### Étape 1 106 | Accédez à la section Nœuds dans Docker Cloud. 107 | 108 | ![](15.png) 109 | 110 | ### Étape 2 111 | Ensuite, vous pouvez donner les détails des noeuds qui seront configurés dans AWS. 112 | 113 | ![](16.png) 114 | 115 | Vous pouvez ensuite cliquer sur le cluster Launch Node qui sera présent au bas de l'écran. Une fois le nœud déployé, vous recevrez la notification dans l'écran Cluster Node. 116 | 117 | ![](17.png) 118 | 119 | ## Déploiement d'un service 120 | Après le déploiement d'un nœud, l'étape suivante consiste à déployer un service. Pour ce faire, nous devons effectuer les étapes suivantes. 121 | 122 | ### Étape 1 123 | Accédez à la section Services de Docker Cloud. Cliquez sur le bouton Créer 124 | 125 | ![](18.png) 126 | 127 | ### Étape 2 128 | Choisissez le service requis. Dans notre cas, choisissons le mongo. 129 | 130 | ![](19.png) 131 | 132 | ### Étape 3 133 | Sur l’écran suivant, choisissez l’option Créer et déployer. Cela va commencer à déployer le conteneur Mongo sur votre cluster de nœuds. 134 | 135 | ![](20.png) 136 | 137 | Une fois déployé, vous pourrez voir le conteneur dans un état en cours d'exécution. 138 | 139 | ![](21.png) 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | -------------------------------------------------------------------------------- /Cloud/basic_interface.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Cloud/basic_interface.jpeg -------------------------------------------------------------------------------- /Compose/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Compose/.DS_Store -------------------------------------------------------------------------------- /Compose/README.md: -------------------------------------------------------------------------------- 1 | # Docker Compose 2 | 3 | Docker Compose est utilisé pour exécuter plusieurs conteneurs en tant que service unique. Par exemple, supposons que vous ayez une application nécessitant NGNIX et MySQL, vous pouvez créer un fichier qui lance les deux conteneurs en tant que service sans qu'il soit nécessaire de les démarrer séparément. 4 | 5 | Dans ce chapitre, nous verrons comment commencer à utiliser Docker Compose. Ensuite, nous verrons comment obtenir un service simple avec MySQL et NGNIX opérationnel avec Docker Compose. 6 | 7 | ## Installation 8 | Les étapes suivantes doivent être suivies pour que Docker Compose soit opérationnel. 9 | 10 | ### Étape 1 11 | Téléchargez les fichiers nécessaires à partir de github en utilisant la commande suivante 12 | ```sh 13 | $ curl -L "https://github.com/docker/compose/releases/download/1.10.0-rc2/dockercompose 14 | -$(uname -s) -$(uname -m)" -o /home/demo/docker-compose 15 | ``` 16 | La commande ci-dessus téléchargera la dernière version de Docker Compose qui, au moment de la rédaction de cet article, est 1.10.0-rc2. Il sera ensuite stocké dans le répertoire /home/demo/. 17 | 18 | ### Étape 2 19 | Ensuite, nous devons fournir les privilèges d'exécution au fichier Docker Compose téléchargé, à l'aide de la commande suivante 20 | ```sh 21 | $ chmod +x /home/demo/docker-compose 22 | ``` 23 | 24 | Nous pouvons ensuite utiliser la commande suivante pour voir la version composée. 25 | ```sh 26 | $ sudo ./docker-compose -version 27 | ``` 28 | Output 29 | 30 | ![](docker_compose_installation.jpeg) 31 | 32 | ## Création de votre premier fichier Docker-Compose 33 | Continuons maintenant et créons notre premier fichier Docker Compose. Tous les fichiers Docker Compose sont des fichiers YAML. Vous pouvez en créer un en utilisant l'éditeur vim. Alors exécutez la commande suivante pour créer le fichier de composition 34 | ```sh 35 | $ sudo vim docker-compose.yml 36 | ``` 37 | ![](compose_file.jpeg) 38 | 39 | Examinons de près les différents détails de ce fichier: 40 | 41 | * La base de données et le mot clé Web permettent de définir deux services distincts. L’un utilisera notre base de données mysql et l’autre sera notre serveur Web nginx. 42 | * Le mot clé image est utilisé pour spécifier l'image à partir de dockerhub pour nos conteneurs mysql et nginx 43 | * Pour la base de données, nous utilisons le mot-clé ports pour mentionner les ports devant être exposés pour mysql. 44 | * Et ensuite, nous spécifions également les variables d'environnement pour mysql qui sont nécessaires pour exécuter mysql. 45 | 46 | Maintenant, exécutons notre fichier Docker Compose en utilisant la commande suivante: 47 | ```sh 48 | $ sudo ./docker-compose up 49 | ``` 50 | Cette commande prendra le fichier docker-compose.yml dans votre répertoire local et commencera à créer les conteneurs. 51 | Une fois exécutées, toutes les images commenceront à télécharger et les conteneurs commenceront automatiquement. 52 | Et lorsque vous effectuez un docker ps, vous pouvez voir que les conteneurs sont effectivement opérationnels. 53 | 54 | 55 | 56 | 57 | 58 | -------------------------------------------------------------------------------- /Compose/compose_file.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Compose/compose_file.jpeg -------------------------------------------------------------------------------- /Compose/docker_compose_installation.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Compose/docker_compose_installation.jpeg -------------------------------------------------------------------------------- /Construction-fichiers/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM ubuntu 2 | MAINTAINER demousr@gmail.com 3 | 4 | RUN apt-get update 5 | RUN apt-get install –y nginx 6 | CMD [“echo”,”Image created”] 7 | -------------------------------------------------------------------------------- /Construction-fichiers/README.md: -------------------------------------------------------------------------------- 1 | # Construction de fichiers 2 | 3 | Nous avons créé notre fichier Docker dans le dernier chapitre. Il est maintenant temps de créer le fichier Docker. Le fichier Docker peut être construit avec la commande suivante 4 | ```sh 5 | $ sudo docker build 6 | ``` 7 | 8 | ## docker build 9 | ```sh 10 | $ sudo docker build -t ImageName:TagName dir 11 | ``` 12 | * -t - est de mentionner une balise à l'image 13 | * ImageName - C'est le nom que vous voulez donner à votre image. 14 | * TagName - Ceci est la balise que vous voulez donner à votre image. 15 | * Dir - Le répertoire où le fichier Docker est présent. 16 | 17 | ### Exemple: 18 | ```sh 19 | $ sudo docker build -t my_image . 20 | ``` 21 | 22 | Output: 23 | 24 | ![](docker-build.png) 25 | 26 | -------------------------------------------------------------------------------- /Construction-fichiers/docker-build.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Construction-fichiers/docker-build.png -------------------------------------------------------------------------------- /Container-hosts/README.md: -------------------------------------------------------------------------------- 1 | # Container and Hosts 2 | 3 | La bonne chose à propos du moteur Docker est qu’il est conçu pour fonctionner sur différents systèmes d’exploitation. Nous avons déjà vu l'installation sur Linux et toutes les commandes Docker sur les systèmes Linux. 4 | 5 | ## Comprendre Docker "Container Host" vs. "Container OS" for Linux et Windows Containers 6 | 7 | Permet d'explorer la relation entre «Container Host» et le «Container OS» et leur différence entre les conteneurs Linux et Windows. 8 | 9 | * Container Host: également appelé système d'exploitation hôte. Le système d'exploitation hôte est le système d'exploitation sur lequel le client Docker et le démon Docker s'exécutent. Dans le cas de conteneurs Linux et non-Hyper-V, le système d'exploitation hôte partage son noyau avec les conteneurs Docker en cours d'exécution. Pour Hyper-V, chaque conteneur a son propre noyau Hyper-V. 10 | * Container OS: Aussi appelé système d'exploitation de base. Le système d'exploitation de base fait référence à une image contenant un système d'exploitation tel que Ubuntu, CentOS ou windowsservercore. En règle générale, vous construisez votre propre image par-dessus une image du système d'exploitation de base afin de pouvoir utiliser certaines parties du système d'exploitation. Notez que les conteneurs Windows requièrent un système d'exploitation de base, contrairement aux conteneurs Linux. 11 | * Operating System Kernel: le noyau gère les fonctions de niveau inférieur telles que la gestion de la mémoire, le système de fichiers, la planification du réseau et des processus. 12 | 13 | ![](linuxcontainers.png) 14 | 15 | ![](windowscontainer.png) 16 | 17 | ![](windowshypercontainer.png) 18 | 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /Container-hosts/linuxcontainers.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Container-hosts/linuxcontainers.png -------------------------------------------------------------------------------- /Container-hosts/windowscontainer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Container-hosts/windowscontainer.png -------------------------------------------------------------------------------- /Container-hosts/windowshypercontainer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Container-hosts/windowshypercontainer.png -------------------------------------------------------------------------------- /Containers-Shells/README.md: -------------------------------------------------------------------------------- 1 | # Containers and Shells 2 | 3 | Par défaut, lorsque vous lancez un conteneur, vous utiliserez également une commande shell lors du lancement du conteneur, comme indiqué ci-dessous. C'est ce que nous avons vu dans les chapitres précédents lorsque nous travaillions avec des conteneurs. 4 | 5 | ```sh 6 | $ sudo docker run -i -t centos /bin/bash 7 | ``` 8 | Nous avons utilisé cette commande pour créer un nouveau conteneur, puis la commande Ctrl + P + Q pour sortir du conteneur. Cela garantit que le conteneur existe toujours, même après sa sortie du conteneur. 9 | 10 | ## Partager des ressources système avec un conteneur 11 | 12 | Jusqu'à présent, nous avons créé quelques images autonomes. Que se passe-t-il lorsque nous souhaitons partager des ressources locales de notre système hôte avec un conteneur? Docker peut partager le système de fichiers et la pile réseau avec des conteneurs. 13 | 14 | Créons un serveur Web qui sert une page Web à partir du système de fichiers local. Nous allons utiliser une image publique Nginx. 15 | 16 | Tout d'abord, nous avons besoin d'un fichier HTML à afficher lorsque nous nous connectons au serveur Web. Démarrez dans un répertoire vide appelé my-nginx et créez un seul sous-répertoire nommé html. Dans html, créez index.html: 17 | 18 | ```sh 19 | $ sudo docker run -v /full/path/to/html/directory:/usr/share/nginx/html:ro -p 8080:80 -d nginx 20 | ``` 21 | Lorsque nous exécutons cette ligne de commande, nous voyons Docker télécharger l'image Nginx, puis démarrer le conteneur. 22 | 23 | * Nous avons utilisé quatre options de ligne de commande pour exécuter ce conteneur: 24 | 25 | * -v /full/path/to/html/directory:/usr/share/nginx/html:ro mappe le répertoire contenant notre page Web vers l'emplacement requis dans l'image. Le champ ro indique à Docker de le monter en mode lecture seule. Il est préférable de transmettre à Docker les chemins complets lors de la spécification des répertoires d’hôte. 26 | * -p 8080:80 mappe le port de service réseau 80 du conteneur sur 8080 sur notre système hôte. 27 | * -d détache le conteneur de notre session en ligne de commande. Contrairement à nos deux exemples précédents, nous ne souhaitons pas interagir avec ce conteneur. 28 | * nginx est le nom de l'image. 29 | 30 | Après avoir exécuté cette commande, nous devrions pouvoir atteindre le serveur Web sur le port 8080: 31 | 32 | ![](web-page.png) 33 | 34 | Nous voyons notre page de test! Vous pouvez également accéder à la page de nos périphériques de votre réseau à l’aide de l’adresse IP de votre système hôte. 35 | 36 | Lorsque nous avons exécuté l’image Nginx, nous devions lui indiquer où obtenir les fichiers Web. Pour ce faire, nous avons monté un répertoire sur notre système hôte dans un répertoire situé à l'intérieur du conteneur, en remplaçant les fichiers déjà présents dans l'image. Docker prend également en charge les volumes pouvant contenir des systèmes de fichiers et être partagés entre des conteneurs. 37 | 38 | Nous devions également mapper le port 80 de notre conteneur sur un port de notre système hôte afin que le serveur Web puisse communiquer avec le monde extérieur. Les conteneurs n’ont pas automatiquement accès au réseau hôte. Avec notre directive de mappage de port, le conteneur est accessible via le réseau hôte. Comme nous avons uniquement mappé ce port, aucune autre ressource réseau n'est disponible pour le conteneur. 39 | 40 | ## Créer une image Docker 41 | 42 | Maintenant, construisons sur cet exemple pour créer notre propre image. Nous allons empaqueter l’image Nginx avec notre fichier html. 43 | 44 | Les images sont créées avec un [fichier Docker](https://docs.docker.com/engine/reference/builder/), qui répertorie les composants et les commandes qui composent une image. 45 | 46 | créer un fichier Docker: 47 | ```sh 48 | FROM nginx 49 | COPY html /usr/share/nginx/html 50 | ``` 51 | Ce fichier Dockerfile contient deux instructions: 52 | 53 | * Tout d’abord, créez cette image à partir d’une image existante, nommée nginx. L'instruction FROM est une exigence pour tous les fichiers Dockerfiles et établit l'image de base. Les instructions suivantes sont exécutées sur l'image de base. 54 | * La deuxième instruction, COPY, indique à Docker de copier notre arborescence de fichiers dans l'image de base, en remplaçant le contenu de / usr / share / nginx / html dans l'image de base. 55 | 56 | Next, build the image:: 57 | ```sh 58 | $ sudo docker build -t mynginx . 59 | 60 | output: 61 | Sending build context to Docker daemon 3.584kB 62 | Step 1/2 : FROM nginx 63 | ---> b175e7467d66 64 | Step 2/2 : COPY html /usr/share/nginx/html 65 | ---> Using cache 66 | ---> a8b02c2e09a4 67 | Successfully built a8b02c2e09a4 68 | Successfully tagged mynginx:latest 69 | ``` 70 | Nous avons passé deux arguments pour construire: 71 | * -t mynginx a donné à Docker une étiquette pour l'image. Comme nous n’avons fourni qu’un nom, nous pouvons voir que Docker a étiqueté cette version comme la dernière de la dernière ligne de la sortie de la version. Nous examinerons de plus près le marquage ci-dessous. 72 | * Le dernier argument, point (ou «.»), A demandé à Docker de rechercher le fichier Docker dans le répertoire de travail en cours. 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | -------------------------------------------------------------------------------- /Containers-Shells/web-page.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Containers-Shells/web-page.png -------------------------------------------------------------------------------- /Containers/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Containers/.DS_Store -------------------------------------------------------------------------------- /Containers/README.md: -------------------------------------------------------------------------------- 1 | # Containers 2 | 3 | ![](containers.jpeg) 4 | 5 | Les conteneurs sont des instances d'images Docker pouvant être exécutées à l'aide de la commande d'exécution Docker. L'objectif principal de Docker est d'exécuter des conteneurs. Voyons comment travailler avec des conteneurs. 6 | 7 | ## Exécuter un conteneur: 8 | L'exécution des conteneurs est gérée à l'aide de la commande d'exécution Docker. Pour exécuter un conteneur en mode interactif, lancez d'abord le conteneur Docker. 9 | ```sh 10 | $ sudo docker run –it centos /bin/bash 11 | ``` 12 | 13 | output: 14 | 15 | ![](runcommand.png) 16 | 17 | ## Liste de conteneurs: 18 | Pour voir la liste des images Docker sur le système, vous pouvez exécuter la commande suivante. 19 | ```sh 20 | $ sudo docker container ps 21 | ``` 22 | 23 | ## Docker Cheat Sheet: 24 | 25 | ![](docker-cheat-heet.png) 26 | 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /Containers/containers.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Containers/containers.jpeg -------------------------------------------------------------------------------- /Containers/docker-cheat-heet.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Containers/docker-cheat-heet.png -------------------------------------------------------------------------------- /Containers/runcommand.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Containers/runcommand.png -------------------------------------------------------------------------------- /File/README.md: -------------------------------------------------------------------------------- 1 | # Fichier 2 | 3 | Dans les chapitres précédents, nous avons vu divers fichiers d’image, tels que Centos, téléchargés à partir du hub Docker à partir duquel vous pouvez créer des conteneurs. 4 | Docker also gives you the capability to create your own Docker images, and it can be done with the help of Docker Files. A Docker File is a simple text file with instructions on how to build your images. 5 | 6 | ## Créer un fichier Docker: 7 | ### Étape 1 8 | Créez un fichier appelé fichier Docker et modifiez-le à l'aide de vim. Veuillez noter que le nom du fichier doit être "Dockerfile" avec "D" en majuscule. 9 | ```sh 10 | $ sudo vim Dockerfile 11 | ``` 12 | 13 | ### Étape 2 14 | Construisez votre fichier Docker en utilisant les instructions suivantes. 15 | ```sh 16 | FROM ubuntu 17 | MAINTAINER demousr@gmail.com 18 | 19 | RUN apt-get update 20 | RUN apt-get install –y nginx 21 | CMD [“echo”,”Image created”] 22 | ``` 23 | Les points suivants doivent être notés à propos du fichier ci-dessus: 24 | 25 | * La première ligne doit commencer par le mot clé FROM. Il indique à docker, à partir de quelle image de base vous souhaitez baser votre image. Dans notre exemple, nous créons une image à partir de l'image d'ubuntu. 26 | * La commande suivante est la personne qui va conserver cette image. Ici, vous spécifiez le mot clé MAINTAINER et ne mentionnez que l'ID de messagerie. 27 | * La commande RUN est utilisée pour exécuter des instructions sur l'image. Dans notre cas, nous mettons d'abord à jour notre système Ubuntu, puis nous installons le serveur nginx sur notre image Ubuntu. 28 | * La dernière commande est utilisée pour afficher un message à l'utilisateur. 29 | 30 | ### Étape 3 31 | Enregistrez le fichier. Dans le prochain chapitre, nous verrons comment construire l’image. -------------------------------------------------------------------------------- /Gestion-ports/README.md: -------------------------------------------------------------------------------- 1 | # Gestion des ports 2 | 3 | Dans Docker, les conteneurs eux-mêmes peuvent avoir des applications s'exécutant sur des ports. Lorsque vous exécutez un conteneur, si vous souhaitez accéder à l'application qu'il contient via un numéro de port, vous devez mapper le numéro de port du conteneur sur le numéro de port de l'hôte Docker. Voyons un exemple de la façon dont cela peut être réalisé. 4 | 5 | ## Exemple: 6 | Dans notre exemple, nous allons télécharger le conteneur Jenkins à partir de Docker Hub. Nous allons ensuite mapper le numéro de port Jenkins au numéro de port sur l'hôte Docker. 7 | ```sh 8 | $ sudo docker pull jenkins 9 | ``` 10 | 11 | ![](pull.png) 12 | 13 | * Pour comprendre quels ports sont exposés par le conteneur, vous devez utiliser la commande inspecter Docker pour inspecter l'image. 14 | ```sh 15 | $ sudo docker inspect jenkins 16 | ``` 17 | 18 | output: 19 | 20 | ![](inspect.png) 21 | 22 | La sortie de la commande inspecte donne une sortie JSON. Si nous observons la sortie, nous pouvons voir qu’il existe une section de "ExposedPorts" et voir que deux ports sont mentionnés. L'un est le port de données de 8080 et l'autre est le port de contrôle de 50000. 23 | 24 | 25 | * To run Jenkins and map the ports, you need to change the Docker run command and add the ‘p’ option which specifies the port mapping. So, you need to run the following command 26 | ```sh 27 | $ sudo docker run -p 8080:8080 -p 50000:50000 jenkins 28 | ``` 29 | Le côté gauche du mappage de numéro de port est le port de l'hôte Docker vers lequel mapper et le côté droit est le numéro de port du conteneur Docker. 30 | 31 | * Lorsque vous ouvrez le navigateur et accédez à l'hôte Docker sur le port 8080, Jenkins est opérationnel. 32 | 33 | ![](webpage.png) -------------------------------------------------------------------------------- /Gestion-ports/inspect.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Gestion-ports/inspect.png -------------------------------------------------------------------------------- /Gestion-ports/pull.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Gestion-ports/pull.png -------------------------------------------------------------------------------- /Gestion-ports/webpage.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Gestion-ports/webpage.png -------------------------------------------------------------------------------- /Hub/README.md: -------------------------------------------------------------------------------- 1 | # Hub 2 | 3 | [Docker Hub](https://www.docker.com/community-edition#/add_ons) est un service de registre sur le cloud qui vous permet de télécharger des images Docker construites par d'autres communautés. Vous pouvez également télécharger vos propres images construites par Docker sur le hub Docker. Dans ce chapitre, nous verrons comment télécharger et utiliser l’image Jenkins Docker à partir du hub Docker. 4 | 5 | ## Étape 1: 6 | Vous devez d’abord effectuer une inscription simple sur [le hub Docker](https://www.docker.com/community-edition#/add_ons). 7 | 8 | ## Étape 2: 9 | Une fois que vous vous êtes inscrit, vous serez connecté à Docker Hub. 10 | 11 | ## Étape 3: 12 | Ensuite, regardons et trouvons l’image Jenkins. 13 | 14 | ## Étape 4: 15 | Si vous faites défiler la même page, vous pouvez voir la commande Docker. Ceci sera utilisé pour télécharger l'image Jenkins sur le serveur Ubuntu local. 16 | 17 | ## Étape 5: 18 | Maintenant, allez sur le serveur Ubuntu et exécutez la commande suivante 19 | ```sh 20 | $ sudo docker pull jenkins 21 | ``` 22 | 23 | ## Étape 6: 24 | Pour exécuter Jenkins, vous devez exécuter la commande suivante: 25 | ```sh 26 | $ sudo docker run -p 8080:8080 -p 50000:50000 jenkins 27 | ``` 28 | 29 | Notez les points suivants concernant la commande sudo ci-dessus: 30 | * Nous utilisons la commande sudo pour nous assurer qu’elle fonctionne avec un accès root. 31 | * Jenkins est le nom de l’image que nous souhaitons télécharger à partir du hub Docker et installer sur notre machine Ubuntu. 32 | * -p est utilisé pour mapper le numéro de port de l'image Docker interne sur notre serveur Ubuntu principal afin que nous puissions accéder au conteneur en conséquence. 33 | -------------------------------------------------------------------------------- /Images/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Images/.DS_Store -------------------------------------------------------------------------------- /Images/README.md: -------------------------------------------------------------------------------- 1 | # Images 2 | 3 | ![](docker-flow.png) 4 | 5 | Dans Docker, tout est basé sur Images. Une image est une combinaison d'un système de fichiers et de paramètres. Prenons un exemple de la commande suivante dans Docker. 6 | ```sh 7 | $ docker run hello-world 8 | ``` 9 | * La commande Docker est spécifique et indique au programme Docker du système d’exploitation qu’il faut faire quelque chose. 10 | * La commande run est utilisée pour indiquer que nous voulons créer une instance d'une image, qui s'appelle alors un conteneur. 11 | * Enfin, "hello-world" représente l'image à partir de laquelle le conteneur est fabriqué. 12 | 13 | ## Exemple: 14 | Voyons comment utiliser l’image CentOS disponible dans Docker Hub pour exécuter CentOS sur notre ordinateur Ubuntu. Nous pouvons le faire en exécutant la commande suivante sur notre machine Ubuntu: 15 | ```sh 16 | $ sudo docker run centos –it /bin/bash 17 | ``` 18 | * Nous utilisons la commande sudo pour nous assurer qu’elle fonctionne avec un accès root. 19 | * Centos est le nom de l'image que nous voulons télécharger depuis Docker Hub et installer sur notre machine Ubuntu. 20 | * Il est utilisé pour mentionner que nous voulons fonctionner en mode interactif. 21 | * /bin/bash est utilisé pour exécuter le shell bash une fois que CentOS est opérationnel. 22 | 23 | ## Affichage des images Docker: 24 | Pour voir la liste des images Docker sur le système, vous pouvez exécuter la commande suivante. 25 | ```sh 26 | $ sudo docker images 27 | ``` 28 | * Output: 29 | 30 | ![](dockerimages.png) 31 | 32 | Chaque image a les attributs suivants: 33 | * TAG − This is used to logically tag images. 34 | * Image ID − This is used to uniquely identify the image. 35 | * Created − The number of days since the image was created. 36 | * Size − The size of the image. 37 | 38 | ## Téléchargement d'images Docker: 39 | ```sh 40 | $ docker run image 41 | ``` 42 | 43 | ## Suppression des images Docker: 44 | ```sh 45 | $ docker rmi ImageID 46 | ``` 47 | 48 | ## docker inspect: 49 | ```sh 50 | $ docker inspect Repository 51 | ``` 52 | * Exemple: 53 | ```sh 54 | $ sudo docker inspect couchdb 55 | ``` 56 | Output: 57 | ```sh 58 | [ 59 | { 60 | "Id": "sha256:269ffb1d6de06ceee9dc67f21ce4c9a98c72c64ae75beb717cd3891f6f17c24b", 61 | "RepoTags": [ 62 | "couchdb:latest" 63 | ], 64 | "RepoDigests": [ 65 | "couchdb@sha256:7d60986a0b43015711121909c50b94dd6a1a6520f8f4bc72f52109b9ea8a17ad" 66 | ], 67 | "Parent": "", 68 | "Comment": "", 69 | "Created": "2018-10-16T01:38:59.501794757Z", 70 | "Container": "70735b7b1c0ae12bd92fc6c9c489f77243d9b149d3951a0b1250fd442c3cf837", 71 | "ContainerConfig": { 72 | "Hostname": "70735b7b1c0a", 73 | "Domainname": "", 74 | "User": "", 75 | "AttachStdin": false, 76 | "AttachStdout": false, 77 | "AttachStderr": false, 78 | "ExposedPorts": { 79 | "4369/tcp": {}, 80 | "5984/tcp": {}, 81 | "9100/tcp": {} 82 | }, 83 | "Tty": false, 84 | "OpenStdin": false, 85 | "StdinOnce": false, 86 | "Env": [ 87 | "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", 88 | "GOSU_VERSION=1.10", 89 | "TINI_VERSION=0.16.1", 90 | "GPG_KEYS=15DD4F3B8AACA54740EB78C7B7B7C53943ECCEE1 1CFBFA43C19B6DF4A0CA3934669C02FFDF3CEBA3 25BBBAC113C1BFD5AA594A4C9F96B92930380381 4BFCA2B99BADC6F9F105BEC9C5E32E2D6B065BFB 5D680346FAA3E51B29DBCB681015F68F9DA248BC 7BCCEB868313DDA925DF1805ECA5BCB7BB9656B0 C3F4DFAEAD621E1C94523AEEC376457E61D50B88 D2B17F9DA23C0A10991AF2E3D9EE01E47852AEE4 E0AF0A194D55C84E4A19A801CDB0C0F904F4EE9B 29E4F38113DF707D722A6EF91FE9AF73118F1A7C 2EC788AE3F239FA13E82D215CDE711289384AE37", 91 | "COUCHDB_VERSION=2.2.0" 92 | ], 93 | "Cmd": [ 94 | "/bin/sh", 95 | "-c", 96 | "#(nop) ", 97 | "CMD [\"/opt/couchdb/bin/couchdb\"]" 98 | ], 99 | "ArgsEscaped": true, 100 | "Image": "sha256:e5fa399062532c209120babef4438265d02293dc766b410b42c4df6d888afc85", 101 | "Volumes": { 102 | "/opt/couchdb/data": {} 103 | }, 104 | "WorkingDir": "/opt/couchdb", 105 | "Entrypoint": [ 106 | "tini", 107 | "--", 108 | "/docker-entrypoint.sh" 109 | ], 110 | "OnBuild": [], 111 | "Labels": {} 112 | }, 113 | "DockerVersion": "17.06.2-ce", 114 | "Author": "CouchDB Developers dev@couchdb.apache.org", 115 | "Config": { 116 | "Hostname": "", 117 | "Domainname": "", 118 | "User": "", 119 | "AttachStdin": false, 120 | "AttachStdout": false, 121 | "AttachStderr": false, 122 | "ExposedPorts": { 123 | "4369/tcp": {}, 124 | "5984/tcp": {}, 125 | "9100/tcp": {} 126 | }, 127 | "Tty": false, 128 | "OpenStdin": false, 129 | "StdinOnce": false, 130 | "Env": [ 131 | "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", 132 | "GOSU_VERSION=1.10", 133 | "TINI_VERSION=0.16.1", 134 | "GPG_KEYS=15DD4F3B8AACA54740EB78C7B7B7C53943ECCEE1 1CFBFA43C19B6DF4A0CA3934669C02FFDF3CEBA3 25BBBAC113C1BFD5AA594A4C9F96B92930380381 4BFCA2B99BADC6F9F105BEC9C5E32E2D6B065BFB 5D680346FAA3E51B29DBCB681015F68F9DA248BC 7BCCEB868313DDA925DF1805ECA5BCB7BB9656B0 C3F4DFAEAD621E1C94523AEEC376457E61D50B88 D2B17F9DA23C0A10991AF2E3D9EE01E47852AEE4 E0AF0A194D55C84E4A19A801CDB0C0F904F4EE9B 29E4F38113DF707D722A6EF91FE9AF73118F1A7C 2EC788AE3F239FA13E82D215CDE711289384AE37", 135 | "COUCHDB_VERSION=2.2.0" 136 | ], 137 | "Cmd": [ 138 | "/opt/couchdb/bin/couchdb" 139 | ], 140 | "ArgsEscaped": true, 141 | "Image": "sha256:e5fa399062532c209120babef4438265d02293dc766b410b42c4df6d888afc85", 142 | "Volumes": { 143 | "/opt/couchdb/data": {} 144 | }, 145 | "WorkingDir": "/opt/couchdb", 146 | "Entrypoint": [ 147 | "tini", 148 | "--", 149 | "/docker-entrypoint.sh" 150 | ], 151 | "OnBuild": [], 152 | "Labels": null 153 | }, 154 | "Architecture": "amd64", 155 | "Os": "linux", 156 | "Size": 252239692, 157 | "VirtualSize": 252239692, 158 | "GraphDriver": { 159 | "Data": { 160 | "LowerDir": "/var/lib/docker/overlay2/568d41e3aea8fea032fe13a8d8812c40673ede17534e806781e10d2a7a50726b/diff:/var/lib/docker/overlay2/3544503aac04726cd6cd895b5158b47adee005f5155a9e5c71ce6b1a82805cb6/diff:/var/lib/docker/overlay2/23492bec80154e2f3aa079902f5dbfb166c35dad68bdcf66d7e732973603299e/diff:/var/lib/docker/overlay2/1dce1c692b0729aa04c8b031ac0788f59029c7edca8be25678f6305036b2f719/diff:/var/lib/docker/overlay2/51a7a05cdc92919cb5a4306e78792d5403ff0a16a7921f09aa3304b3871b4a2e/diff:/var/lib/docker/overlay2/c65cefb2e61e4a5a8af5fb90a5d3994001a61720d4bc0a4276bf683d3f9667e9/diff:/var/lib/docker/overlay2/944056cd33cd8b5b2314f2bc45ce9536ea49dce0d2dc172407866731fbb976ac/diff:/var/lib/docker/overlay2/931273e9d77ff341e84c23e72f358e1095755e1ab73b43b9c920482dfd580c77/diff:/var/lib/docker/overlay2/d8e3c1e9dccdc90e1b9f74d14d28cf94878004105a81c5bd6b027716c78526cd/diff", 161 | "MergedDir": "/var/lib/docker/overlay2/3cbecfa24556b25bff395054f9921b7523b3dcf3e95113f8def7dfe396b05c3c/merged", 162 | "UpperDir": "/var/lib/docker/overlay2/3cbecfa24556b25bff395054f9921b7523b3dcf3e95113f8def7dfe396b05c3c/diff", 163 | "WorkDir": "/var/lib/docker/overlay2/3cbecfa24556b25bff395054f9921b7523b3dcf3e95113f8def7dfe396b05c3c/work" 164 | }, 165 | "Name": "overlay2" 166 | }, 167 | "RootFS": { 168 | "Type": "layers", 169 | "Layers": [ 170 | "sha256:f715ed19c28b66943ac8bc12dbfb828e8394de2530bbaf1ecce906e748e4fdff", 171 | "sha256:c379b6eddc1be7ab5baa6525136070dd3ec68dab051ed811200d41141d30c1e7", 172 | "sha256:76fd3ec1268c3d8a73fb8c0312a532be77be17ed087f5d053b00c038c34e8a14", 173 | "sha256:9f44044270f29d8161c47ce7d7dbdefea5311e5607b9751659f4ddcc8f32251e", 174 | "sha256:8e20bc15c63db1f55366cd64c19fc2c4dc81d4c8b25ece905b1aa54d4c4529d5", 175 | "sha256:4b39b481448325d90ce773228cc0e9ce422ea1d58c0917b5f996f5f457bc108d", 176 | "sha256:0a8277dec77974377783cc4eff91817317ffdbcc50a0a7760c0e6945886b6b2f", 177 | "sha256:602291f963faed9185db1e4fa3c477b9393a56c0449f623f359fd07b27358aa3", 178 | "sha256:0448ca461889819cf6755f9aea7373e5b427c4f7b3eba30080a9919002782bdb", 179 | "sha256:3aa440c00095eb7c44a84985cc1632a8a7ba07c7d02b0adffa20562eef6c3e76" 180 | ] 181 | }, 182 | "Metadata": { 183 | "LastTagTime": "0001-01-01T00:00:00Z" 184 | } 185 | } 186 | ] 187 | ``` 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | -------------------------------------------------------------------------------- /Images/docker-flow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Images/docker-flow.png -------------------------------------------------------------------------------- /Images/dockerimages.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Images/dockerimages.png -------------------------------------------------------------------------------- /Installation/README.md: -------------------------------------------------------------------------------- 1 | # Installation 2 | 3 | ![](containers.jpeg) 4 | 5 | ## Conditions préalables 6 | Pour suivre ce tutoriel, vous aurez besoin des éléments suivants: 7 | 8 | * Un serveur Ubuntu 16.04 configuré avec un utilisateur non root avec des privilèges sudo et un pare-feu de base, comme expliqué dans [le Guide de configuration initiale pour Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-16-04) 9 | * Un compte sur [Docker Hub](https://hub.docker.com/) si vous souhaitez créer vos propres images et les transférer sur Docker Hub. 10 | 11 | ## Étape 1: 12 | Avant d’installer Docker, vous devez d’abord vérifier que vous avez la bonne version du noyau Linux en cours d’exécution. Docker est uniquement conçu pour fonctionner sur les versions 3.8 et supérieures du noyau Linux. Nous pouvons le faire en exécutant la commande suivante. 13 | ```sh 14 | $ uname -a 15 | ``` 16 | 17 | ## Étape 2: 18 | Vous devez mettre à jour le système d’exploitation avec les derniers packages, ce qui peut être fait à l’aide de la commande suivante 19 | ```sh 20 | $ sudo apt-get update 21 | ``` 22 | 23 | ## Étape 3: 24 | L'étape suivante consiste à installer les certificats nécessaires pour pouvoir utiliser le site Docker ultérieurement afin de télécharger les packages Docker nécessaires. Cela peut être fait avec la commande suivante. 25 | ```sh 26 | $ sudo apt-get install apt-transport-https ca-certificates 27 | ``` 28 | 29 | ## Étape 4: 30 | Le package d'installation de Docker disponible dans le référentiel officiel Ubuntu 16.04 peut ne pas être la dernière version. Pour obtenir cette dernière version, installez Docker à partir du référentiel officiel de Docker. Cette section vous montre comment faire exactement cela. 31 | 32 | Tout d'abord, afin de vous assurer que les téléchargements sont valides, ajoutez la clé GPG du référentiel officiel Docker à votre système: 33 | ```sh 34 | $ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - 35 | ``` 36 | Ajoutez le référentiel Docker aux sources APT: 37 | ```sh 38 | $ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" 39 | ``` 40 | Assurez-vous que vous êtes sur le point d'installer à partir du référentiel Docker au lieu du référentiel par défaut Ubuntu 16.04: 41 | ```sh 42 | $ apt-cache policy docker-ce 43 | ``` 44 | Vous devriez voir une sortie similaire à celle-ci: 45 | ```sh 46 | docker-ce: 47 | Installed: (none) 48 | Candidate: 18.06.1~ce~3-0~ubuntu 49 | Version table: 50 | 18.06.1~ce~3-0~ubuntu 500 51 | 500 https://download.docker.com/linux/ubuntu xenial/stable amd64 Packages 52 | ``` 53 | Enfin, installez Docker: 54 | ```sh 55 | $ sudo apt-get install -y docker-ce 56 | ``` 57 | Docker should now be installed, the daemon started, and the process enabled to start on boot. Check that it's running: 58 | ```sh 59 | $ sudo systemctl status docker 60 | ``` 61 | The output should be similar to the following, showing that the service is active and running: 62 | ```sh 63 | Output 64 | ● docker.service - Docker Application Container Engine 65 | Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled) 66 | Active: active (running) since Thu 2018-10-18 20:28:23 UTC; 35s ago 67 | Docs: https://docs.docker.com 68 | Main PID: 13412 (dockerd) 69 | CGroup: /system.slice/docker.service 70 | ├─13412 /usr/bin/dockerd -H fd:// 71 | └─13421 docker-containerd --config /var/run/docker/containerd/containerd.toml 72 | ``` 73 | L'installation de Docker vous donne maintenant non seulement le service Docker (démon), mais également l'utilitaire de ligne de commande Docker ou le client Docker. Nous verrons comment utiliser la commande docker plus loin dans ce tutoriel. -------------------------------------------------------------------------------- /Installation/containers.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Installation/containers.jpeg -------------------------------------------------------------------------------- /Kubernetes/README.md: -------------------------------------------------------------------------------- 1 | # Fonctionnement de Kubernetes 2 | 3 | Dans ce chapitre, nous verrons comment installer Kubernetes via kubeadm. C'est un outil qui aide à l'installation de Kubernetes. Allons-y étape par étape pour apprendre à installer Kubernetes. 4 | 5 | ## Étape 1 6 | Assurez-vous que la version du serveur Ubuntu sur laquelle vous travaillez est 16.04. 7 | 8 | ## Étape 2 9 | Assurez-vous de générer une clé ssh pouvant être utilisée pour la connexion ssh. Vous pouvez le faire en utilisant la commande suivante. 10 | ```sh 11 | $ ssh-keygen 12 | ``` 13 | 14 | ## Étape 3 15 | Ensuite, en fonction de votre version d’Ubuntu, vous devrez ajouter le site correspondant au fichier docker.list pour le gestionnaire de paquets apt, afin qu’il puisse détecter les paquets Kubernetes sur le site kubernetes et les télécharger. en conséquence. 16 | 17 | Nous pouvons le faire en utilisant les commandes suivantes. 18 | ```sh 19 | $ curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add - 20 | echo "deb http://apt.kubernetes.io/ kubernetes-xenial main” | sudo tee /etc/apt/sources.list.d/docker.list 21 | ``` 22 | 23 | ## Étape 4 24 | Nous publions ensuite une mise à jour d'apt-get pour nous assurer que tous les paquets sont téléchargés sur le serveur Ubuntu. 25 | 26 | ## Étape 5 27 | Installez le package Docker comme indiqué dans les chapitres précédents. 28 | 29 | ## Étape 6 30 | Il est maintenant temps d’installer kubernetes en installant les packages suivants: 31 | ```sh 32 | $ apt-get install –y kubelet kubeadm kubectl kubernetes-cni 33 | ``` 34 | 35 | ## Étape 7 36 | Une fois tous les packages kubernetes téléchargés, il est temps de démarrer le contrôleur kubernetes à l’aide de la commande suivante: 37 | ```sh 38 | $ kubeadm init 39 | ``` 40 | 41 | Une fois cela fait, vous obtiendrez un message indiquant que le maître est opérationnel et que les nœuds peuvent maintenant rejoindre le cluster. -------------------------------------------------------------------------------- /KubernetesArchitecture/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/KubernetesArchitecture/.DS_Store -------------------------------------------------------------------------------- /KubernetesArchitecture/README.md: -------------------------------------------------------------------------------- 1 | # Architecture Kubernetes 2 | 3 | Kubernetes est un framework d'orchestration pour les conteneurs Docker qui aide à exposer les conteneurs en tant que services au monde extérieur. Par exemple, vous pouvez avoir deux services: un service contiendrait nginx et mongoDB, et un autre service contiendrait nginx et redis. Chaque service peut avoir un IP ou un point de service pouvant être connecté par d'autres applications. Kubernetes est ensuite utilisé pour gérer ces services. 4 | 5 | Le diagramme suivant montre dans un format simpliste le fonctionnement de Kubernetes du point de vue de l’architecture. 6 | 7 | ![](kubernetes_architecture.jpeg) 8 | 9 | Le séide est le nœud sur lequel tous les services sont exécutés. Vous pouvez avoir plusieurs sbires en cours d'exécution à un moment donné. Chaque séide accueillera un ou plusieurs POD. Chaque POD est comme l'hébergement d'un service. Chaque POD contient ensuite les conteneurs Docker. Chaque POD peut héberger un ensemble différent de conteneurs Docker. Le proxy est ensuite utilisé pour contrôler l'exposition de ces services au monde extérieur. 10 | 11 | Kubernetes a plusieurs composants dans son architecture. Le rôle de chaque composant est expliqué ci-dessous & mius; 12 | 13 | * etcd - Ce composant est un magasin clé-valeur hautement disponible utilisé pour stocker la configuration partagée et la découverte de services. Ici, les différentes applications pourront se connecter aux services via le service de découverte. 14 | * Flannel - Il s’agit d’un réseau principal qui est requis pour les conteneurs. 15 | * kube-apiserver - Il s'agit d'une API qui peut être utilisée pour orchestrer les conteneurs Docker. 16 | * kube-controller-manager - Ceci est utilisé pour contrôler les services Kubernetes. 17 | * kube-scheduler - Ceci est utilisé pour planifier les conteneurs sur les hôtes. 18 | * Kubelet - Ceci est utilisé pour contrôler le lancement des conteneurs via des fichiers manifest. 19 | * kube-proxy - Ceci est utilisé pour fournir des services de proxy réseau au monde extérieur. 20 | 21 | -------------------------------------------------------------------------------- /KubernetesArchitecture/kubernetes_architecture.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/KubernetesArchitecture/kubernetes_architecture.jpeg -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU LESSER GENERAL PUBLIC LICENSE 2 | Version 3, 29 June 2007 3 | 4 | Copyright (C) 2007 Free Software Foundation, Inc. 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | 9 | This version of the GNU Lesser General Public License incorporates 10 | the terms and conditions of version 3 of the GNU General Public 11 | License, supplemented by the additional permissions listed below. 12 | 13 | 0. Additional Definitions. 14 | 15 | As used herein, "this License" refers to version 3 of the GNU Lesser 16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU 17 | General Public License. 18 | 19 | "The Library" refers to a covered work governed by this License, 20 | other than an Application or a Combined Work as defined below. 21 | 22 | An "Application" is any work that makes use of an interface provided 23 | by the Library, but which is not otherwise based on the Library. 24 | Defining a subclass of a class defined by the Library is deemed a mode 25 | of using an interface provided by the Library. 26 | 27 | A "Combined Work" is a work produced by combining or linking an 28 | Application with the Library. The particular version of the Library 29 | with which the Combined Work was made is also called the "Linked 30 | Version". 31 | 32 | The "Minimal Corresponding Source" for a Combined Work means the 33 | Corresponding Source for the Combined Work, excluding any source code 34 | for portions of the Combined Work that, considered in isolation, are 35 | based on the Application, and not on the Linked Version. 36 | 37 | The "Corresponding Application Code" for a Combined Work means the 38 | object code and/or source code for the Application, including any data 39 | and utility programs needed for reproducing the Combined Work from the 40 | Application, but excluding the System Libraries of the Combined Work. 41 | 42 | 1. Exception to Section 3 of the GNU GPL. 43 | 44 | You may convey a covered work under sections 3 and 4 of this License 45 | without being bound by section 3 of the GNU GPL. 46 | 47 | 2. Conveying Modified Versions. 48 | 49 | If you modify a copy of the Library, and, in your modifications, a 50 | facility refers to a function or data to be supplied by an Application 51 | that uses the facility (other than as an argument passed when the 52 | facility is invoked), then you may convey a copy of the modified 53 | version: 54 | 55 | a) under this License, provided that you make a good faith effort to 56 | ensure that, in the event an Application does not supply the 57 | function or data, the facility still operates, and performs 58 | whatever part of its purpose remains meaningful, or 59 | 60 | b) under the GNU GPL, with none of the additional permissions of 61 | this License applicable to that copy. 62 | 63 | 3. Object Code Incorporating Material from Library Header Files. 64 | 65 | The object code form of an Application may incorporate material from 66 | a header file that is part of the Library. You may convey such object 67 | code under terms of your choice, provided that, if the incorporated 68 | material is not limited to numerical parameters, data structure 69 | layouts and accessors, or small macros, inline functions and templates 70 | (ten or fewer lines in length), you do both of the following: 71 | 72 | a) Give prominent notice with each copy of the object code that the 73 | Library is used in it and that the Library and its use are 74 | covered by this License. 75 | 76 | b) Accompany the object code with a copy of the GNU GPL and this license 77 | document. 78 | 79 | 4. Combined Works. 80 | 81 | You may convey a Combined Work under terms of your choice that, 82 | taken together, effectively do not restrict modification of the 83 | portions of the Library contained in the Combined Work and reverse 84 | engineering for debugging such modifications, if you also do each of 85 | the following: 86 | 87 | a) Give prominent notice with each copy of the Combined Work that 88 | the Library is used in it and that the Library and its use are 89 | covered by this License. 90 | 91 | b) Accompany the Combined Work with a copy of the GNU GPL and this license 92 | document. 93 | 94 | c) For a Combined Work that displays copyright notices during 95 | execution, include the copyright notice for the Library among 96 | these notices, as well as a reference directing the user to the 97 | copies of the GNU GPL and this license document. 98 | 99 | d) Do one of the following: 100 | 101 | 0) Convey the Minimal Corresponding Source under the terms of this 102 | License, and the Corresponding Application Code in a form 103 | suitable for, and under terms that permit, the user to 104 | recombine or relink the Application with a modified version of 105 | the Linked Version to produce a modified Combined Work, in the 106 | manner specified by section 6 of the GNU GPL for conveying 107 | Corresponding Source. 108 | 109 | 1) Use a suitable shared library mechanism for linking with the 110 | Library. A suitable mechanism is one that (a) uses at run time 111 | a copy of the Library already present on the user's computer 112 | system, and (b) will operate properly with a modified version 113 | of the Library that is interface-compatible with the Linked 114 | Version. 115 | 116 | e) Provide Installation Information, but only if you would otherwise 117 | be required to provide such information under section 6 of the 118 | GNU GPL, and only to the extent that such information is 119 | necessary to install and execute a modified version of the 120 | Combined Work produced by recombining or relinking the 121 | Application with a modified version of the Linked Version. (If 122 | you use option 4d0, the Installation Information must accompany 123 | the Minimal Corresponding Source and Corresponding Application 124 | Code. If you use option 4d1, you must provide the Installation 125 | Information in the manner specified by section 6 of the GNU GPL 126 | for conveying Corresponding Source.) 127 | 128 | 5. Combined Libraries. 129 | 130 | You may place library facilities that are a work based on the 131 | Library side by side in a single library together with other library 132 | facilities that are not Applications and are not covered by this 133 | License, and convey such a combined library under terms of your 134 | choice, if you do both of the following: 135 | 136 | a) Accompany the combined library with a copy of the same work based 137 | on the Library, uncombined with any other library facilities, 138 | conveyed under the terms of this License. 139 | 140 | b) Give prominent notice with the combined library that part of it 141 | is a work based on the Library, and explaining where to find the 142 | accompanying uncombined form of the same work. 143 | 144 | 6. Revised Versions of the GNU Lesser General Public License. 145 | 146 | The Free Software Foundation may publish revised and/or new versions 147 | of the GNU Lesser General Public License from time to time. Such new 148 | versions will be similar in spirit to the present version, but may 149 | differ in detail to address new problems or concerns. 150 | 151 | Each version is given a distinguishing version number. If the 152 | Library as you received it specifies that a certain numbered version 153 | of the GNU Lesser General Public License "or any later version" 154 | applies to it, you have the option of following the terms and 155 | conditions either of that published version or of any later version 156 | published by the Free Software Foundation. If the Library as you 157 | received it does not specify a version number of the GNU Lesser 158 | General Public License, you may choose any version of the GNU Lesser 159 | General Public License ever published by the Free Software Foundation. 160 | 161 | If the Library as you received it specifies that a proxy can decide 162 | whether future versions of the GNU Lesser General Public License shall 163 | apply, that proxy's public statement of acceptance of any version is 164 | permanent authorization for you to choose that version for the 165 | Library. 166 | -------------------------------------------------------------------------------- /Linking/README.md: -------------------------------------------------------------------------------- 1 | # Liaison de conteneur 2 | 3 | La liaison de conteneurs permet à plusieurs conteneurs de se lier les uns aux autres. C'est une meilleure option que d'exposer les ports. Allons-y étape par étape et apprenons comment cela fonctionne. 4 | 5 | ## Étape 1 6 | Téléchargez l'image Jenkins, si elle n'est pas déjà présente, à l'aide de la commande Pull Jenkins. 7 | ```sh 8 | $ sudo docker pull jenkins 9 | ``` 10 | 11 | ## Étape 2 12 | Une fois l'image disponible, exécutez le conteneur, mais cette fois-ci, vous pouvez spécifier un nom pour le conteneur à l'aide de l'option –-name. Ce sera notre conteneur source. 13 | ```sh 14 | $ sudo docker run --name=jenkinsa -d jenkins 15 | ``` 16 | 17 | ## Étape 3 18 | Ensuite, il est temps de lancer le conteneur de destination, mais cette fois-ci, nous allons le lier à notre conteneur source. Pour notre conteneur de destination, nous utiliserons l'image standard Ubuntu. 19 | ```sh 20 | $ sudo docker run --name=reca --link=jenkinsa:alias-src -it ubuntu:latest /bin/bash 21 | ``` 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /Logging/README.md: -------------------------------------------------------------------------------- 1 | # Logging 2 | 3 | Docker dispose de mécanismes de journalisation qui peuvent être utilisés pour résoudre les problèmes au fur et à mesure qu'ils surviennent. Il existe une journalisation au niveau du démon et du conteneur. Examinons les différents niveaux de journalisation. 4 | 5 | ## Daemon Logging 6 | Au niveau de la journalisation démon, il existe quatre niveaux de journalisation disponibles: 7 | 8 | * Debug - Il détaille toutes les informations possibles traitées par le processus démon. 9 | * Info - Il détaille toutes les erreurs et les informations gérées par le processus démon. 10 | * Erreurs - Il détaille toutes les erreurs gérées par le processus démon. 11 | * Fatal - Il ne détaille que toutes les erreurs fatales gérées par le processus démon. 12 | 13 | ### Étape 1 14 | Nous devons d’abord arrêter le processus du démon docker, s’il est déjà en cours d’exécution. Cela peut être fait en utilisant la commande suivante 15 | ```sh 16 | $ sudo service docker stop 17 | ``` 18 | 19 | ### Étape 2 20 | Nous devons maintenant démarrer le processus du démon docker. Mais cette fois, nous devons ajouter le paramètre –l pour spécifier l’option de journalisation. Lançons donc la commande suivante lors du démarrage du processus du démon docker. 21 | ```sh 22 | $ sudo dockerd –l debug & 23 | ``` 24 | Les points suivants doivent être notés à propos de la commande ci-dessus: 25 | 26 | * dockerd est l'exécutable du processus du démon docker. 27 | * L'option –l permet de spécifier le niveau de journalisation. Dans notre cas, nous mettons cela comme debug 28 | * & est utilisé pour revenir à l'invite de commande après l'activation de la journalisation. 29 | 30 | Une fois que vous avez démarré le processus Docker avec la journalisation, vous verrez maintenant les journaux de débogage envoyés à la console. 31 | 32 | Désormais, si vous exécutez une commande Docker telle que des images de menu fixe, les informations de débogage seront également envoyées à la console. 33 | 34 | ## Container Logging 35 | La journalisation est également disponible au niveau du conteneur. Dans notre exemple, commençons par créer un conteneur Ubuntu. Nous pouvons le faire en utilisant la commande suivante. 36 | ```sh 37 | $ sudo docker run –it ubuntu /bin/bash 38 | ``` 39 | Nous pouvons maintenant utiliser la commande docker log pour afficher les journaux du conteneur. 40 | ```sh 41 | $ sudo docker logs containerID 42 | ``` -------------------------------------------------------------------------------- /Networking/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Networking/.DS_Store -------------------------------------------------------------------------------- /Networking/Macvlan.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Networking/Macvlan.png -------------------------------------------------------------------------------- /Networking/README.md: -------------------------------------------------------------------------------- 1 | # Networking 2 | 3 | Docker prend en charge les aspects de mise en réseau afin que les conteneurs puissent communiquer avec d'autres conteneurs ainsi qu'avec l'hôte Docker. Si vous effectuez un ifconfig sur l'hôte Docker, vous verrez l'adaptateur Ethernet Docker. Cet adaptateur est créé lorsque Docker est installé sur l'hôte Docker. 4 | 5 | ## Liste de tous les réseaux Docker 6 | ```sh 7 | $ sudo docker network ls 8 | ``` 9 | 10 | Output 11 | 12 | ![](networklist.png) 13 | 14 | ## Inspection d'un réseau Docker 15 | Si vous souhaitez voir plus de détails sur le réseau associé à Docker, vous pouvez utiliser la commande Docker network inspect. 16 | ```sh 17 | $ sudo docker network inspect bridge 18 | ``` 19 | 20 | Output: 21 | vous verrez maintenant que le conteneur 'jenkinsa' est attaché au bridge network: 22 | 23 | ![](inspect.png) 24 | 25 | ## Créer votre propre nouveau réseau 26 | ```sh 27 | $ sudo docker network create –-driver drivername name 28 | ``` 29 | * drivername - C'est le nom utilisé pour le pilote de réseau. 30 | * name - C'est le nom donné au réseau. 31 | 32 | Vous pouvez maintenant connecter le nouveau réseau lors du lancement du conteneur. Alors, faisons tourner un conteneur Ubuntu avec la commande suivante: 33 | ```sh 34 | $ sudo docker run –it –network=new_nw ubuntu:latest /bin/bash 35 | ``` 36 | 37 | ## Host Networking 38 | Partage la pile TCP/IP, l'espace de noms, etc. du système d'exploitation hôte. Autrement dit, toutes les interfaces réseau définies sur l'hôte seront accessibles au conteneur. La commande ci-dessous connecte l'image du docker microservice au réseau hôte. 39 | ```sh 40 | $ sudo docker run --net=host microservice-demo 41 | ``` 42 | 43 | ## Bridge Network 44 | Le Bridge Network fournit des capacités de mise en réseau à hôte unique Par défaut, les conteneurs se connectent au réseau de ponts. Chaque fois que le conteneur démarre, il est fourni une adresse IP interne. Tous les conteneurs connectés au pont interne peuvent désormais communiquer entre eux. Mais ils ne peuvent pas communiquer en dehors du réseau du pont. 45 | Cependant, avec l'option -p, nous pouvons mapper le port du menu fixe sur le port natif. 46 | ```sh 47 | $ docker run -p 4000:80 microservice-demo 48 | ``` 49 | 50 | ## Overlay Networking 51 | Le réseau de superposition fournit un réseau simple et sécurisé à plusieurs hôtes. Le réseau en superposition utilise [VXLAN](https://www.cisco.com/c/en/us/products/collateral/switches/nexus-9000-series-switches/white-paper-c11-729383.html) sur un réseau sous-jacent. 52 | Les conteneurs faisant partie de Overlay Network peuvent communiquer avec des conteneurs, quel que soit l'hôte. Les conteneurs faisant partie du réseau de superposition se voient s’ils se trouvent sur le même réseau L2. 53 | 54 | ![](docker-overlay.png) 55 | 56 | Chaque conteneur du réseau de superposition reçoit deux adresses IP. 57 | First IP permet la communication entre les conteneurs d'un hôte à l'autre. La seconde adresse IP est mappée sur le point de terminaison VXLAN-VTEP et contient toutes les données réelles entre les hôtes. 58 | 59 | ## Macvlan Driver 60 | Il s’agit d’une manière matérielle de mise en réseau où chaque conteneur se voit attribuer une adresse matérielle ou une adresse MAC. En conséquence, chacun des conteneurs possède une pile TCP/IP complète. Cela signifie donc que chaque conteneur agit comme un périphérique physique directement connecté au réseau sous-jacent. 61 | 62 | ![](Macvlan.png) 63 | 64 | Macvlan entraîne toutefois des frais supplémentaires de gestion du réseau, car chaque conteneur est désormais un citoyen de première classe du réseau sous-jacent. 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | -------------------------------------------------------------------------------- /Networking/docker-overlay.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Networking/docker-overlay.png -------------------------------------------------------------------------------- /Networking/inspect.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Networking/inspect.png -------------------------------------------------------------------------------- /Networking/networklist.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Networking/networklist.png -------------------------------------------------------------------------------- /Pratiques/README.md: -------------------------------------------------------------------------------- 1 | # Travailler avec des conteneurs 2 | 3 | Dans ce chapitre, nous explorerons en détail ce que nous pouvons faire avec les conteneurs. 4 | 5 | ## docker top: 6 | Avec cette commande, vous pouvez voir les principaux processus dans un conteneur. 7 | ```sh 8 | $ sudo docker top ContainerID 9 | ``` 10 | * ContainerID - Il s'agit de l'ID de conteneur pour lequel vous souhaitez voir les principaux processus. 11 | 12 | ## docker stop: 13 | Cette commande est utilisée pour arrêter un conteneur en cours d'exécution. 14 | ```sh 15 | $ sudo docker stop ContainerID 16 | ``` 17 | 18 | ## docker rm: 19 | Cette commande est utilisée pour supprimer un conteneur. 20 | ```sh 21 | $ sudo docker rm ContainerID 22 | ``` 23 | 24 | ## docker stats: 25 | Cette commande est utilisée pour fournir les statistiques d'un conteneur en cours d'exécution. 26 | ```sh 27 | $ sudo docker stats ContainerID 28 | ``` 29 | 30 | output: 31 | 32 | ![](stats.png) 33 | 34 | ## docker attach: 35 | Cette commande est utilisée pour attacher à un conteneur en cours d'exécution. 36 | ```sh 37 | $ sudo docker attach ContainerID 38 | ``` 39 | 40 | ## docker pause: 41 | Cette commande est utilisée pour suspendre les processus dans un conteneur en cours d'exécution. 42 | ```sh 43 | $ sudo docker pause ContainerID 44 | ``` 45 | 46 | ## docker unpause: 47 | Cette commande permet de suspendre les processus dans un conteneur en cours d'exécution. 48 | ```sh 49 | $ sudo docker unpause ContainerID 50 | ``` 51 | 52 | ## docker kill: 53 | Cette commande est utilisée pour tuer les processus dans un conteneur en cours d'exécution. 54 | ```sh 55 | $ sudo docker kill ContainerID 56 | ``` 57 | 58 | ## Container Lifecycle: 59 | L'illustration suivante explique le cycle de vie complet d'un conteneur Docker. 60 | 61 | ![](lifecycle.png) 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | -------------------------------------------------------------------------------- /Pratiques/lifecycle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Pratiques/lifecycle.png -------------------------------------------------------------------------------- /Pratiques/stats.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Pratiques/stats.png -------------------------------------------------------------------------------- /Private-registers/README.md: -------------------------------------------------------------------------------- 1 | # Registres privés 2 | 3 | Vous aurez peut-être besoin de disposer de vos propres référentiels privés. Il se peut que vous ne souhaitiez pas héberger les référentiels sur Docker Hub. Pour cela, il existe un conteneur de référentiel lui-même provenant de Docker. Voyons comment nous pouvons télécharger et utiliser le conteneur pour le registre. 4 | 5 | ## Déroulez l'image du registre et Exécuter le registre local 6 | Utilisez la commande Docker run pour télécharger le registre privé. Cela peut être fait en utilisant la commande suivante. 7 | ```sh 8 | $ sudo docker run -d -p 5000:5000 --name localregistry registry 9 | ``` 10 | nous commençons un conteneur nommé ‘localregistry’ basé sur l’image ‘registry’. Le conteneur est démarré en mode détaché et le mappage de port hôte: conteneur a été effectué pour les deux numéros de port 5000. 11 | 12 | ![](newreg.png) 13 | 14 | Vérifiez si le conteneur nommé ‘localregistry’ a démarré via la commande docker ps comme indiqué ci-dessous: 15 | 16 | ![](ps.png) 17 | 18 | ## Déroulez quelques images et appuyez sur le registre local 19 | 20 | ### Étape 1: Déroulez les images busybox et Linux alpin 21 | ```sh 22 | $ sudo docker pull busybox 23 | $ sudo docker pull alpine 24 | ``` 25 | Une fois les images extraites, vérifiez qu’elles figurent dans votre liste d’images via la commande docker images. 26 | Si à ce stade, nous essayons d'extraire l'image alpine de notre registre local, il devrait idéalement répondre avec l'image non trouvée, ne devrait-elle pas? Oui, il sera. N'oubliez pas que nous avons déjà démarré le conteneur de registre sur le port 5000. Le résultat de cette opération est présenté ci-dessous: 27 | ```sh 28 | $ sudo docker pull localhost:5000/alpine 29 | Using default tag: latest 30 | Error response from daemon: manifest for localhost:5000/alpine:latest not found 31 | ``` 32 | Notez que le format de spécification de l'image dans un registre spécifique est le suivant: 33 | ```sh 34 | [REGISTRY_HOSTNAME:REGISTRY_PORT]/IMAGENAME 35 | ``` 36 | Pour Docker Hub public, nous n'avons pas spécifié l'option [REGISTRY_HOSTNAME: REGISTRY_PORT]. Mais pour notre registre local, nous devons spécifier cela afin que le client docker puisse y regarder. 37 | 38 | ### Étape 2: Insérez les images busybox et Linux alpin dans le registre local. 39 | Nous allons maintenant insérer les deux images téléchargées (busybox et alpine) dans le registre local. N'oubliez pas qu'il s'agit de deux images que vous avez téléchargées directement à partir du hub Docker. Nous ne l'avons pas modifié en aucune façon. Mais vous pouvez créer votre propre image modifiée (comme nous l'avons vu précédemment dans cette série) et l'insérer également dans le registre local. 40 | 41 | * La première étape consiste à utiliser votre image ou votre conteneur. Laissez-nous travailler avec l’image alpine que nous avons extraite précédemment. Le nom qualifié complet de cette image est alpine: latest si vous exécutez une commande images docker. Exécutez la commande suivante pour baliser l’alpine: latest image avec la balise du registre local dans lequel nous allons la pousser. 42 | ```sh 43 | $ sudo docker tag alpine:latest localhost:5000/alpine:latest 44 | ``` 45 | Si vous exécutez maintenant une commande d'images fixes, vous verrez les images alpine et localhost: 5000 / alpine répertoriées. 46 | 47 | * L'étape suivante consiste à insérer cette image ou ce conteneur marqué dans le registre local. 48 | Cela se fait via la commande standard du menu fixe que vous avez vue précédemment. Tout ce que nous avons à faire est d'utiliser le nouveau tagged localhost: 5000/alpine image. La commande est donnée ci-dessous: 49 | ```sh 50 | $ docker push localhost:5000/alpine:latest 51 | The push refers to a repository [localhost:5000/alpine] 52 | 04a094fe844e: Pushed 53 | latest: digest: sha256:5cb04fce748f576d7b72a37850641de8bd725365519673c643ef2d14819b42c6 size: 528 54 | ``` 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | -------------------------------------------------------------------------------- /Private-registers/newreg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Private-registers/newreg.png -------------------------------------------------------------------------------- /Private-registers/ps.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Private-registers/ps.png -------------------------------------------------------------------------------- /Public-Repo/README.md: -------------------------------------------------------------------------------- 1 | # Dépôts publics 2 | 3 | ![](repo.png) 4 | 5 | ## Obtenir une image de Docker Hub 6 | Docker Hub est le lieu où sont stockées les images Docker ouvertes. Lorsque nous avons exécuté notre première image en tapant 7 | ```sh 8 | $ sudo docker run --rm -p 8787:8787 rocker/verse 9 | ``` 10 | 11 | le logiciel a d’abord vérifié si cette image était disponible sur votre ordinateur et ne l’avait pas téléchargée depuis Docker Hub. Donc, obtenir une image de Docker Hub fonctionne automatiquement. Si vous voulez seulement tirer l’image mais ne pas la lancer, vous pouvez aussi le faire. 12 | ```sh 13 | $ sudo docker pull rocker/verse 14 | ``` 15 | 16 | ## Obtenir une image sur Docker Hub 17 | Imaginez que vous avez créé votre propre image Docker et que vous souhaitez la partager avec le monde entier. Vous pouvez créer un compte sur https://hub.docker.com/. Après avoir vérifié votre courrier électronique, vous êtes prêt à télécharger votre première image de menu fixe. 18 | 19 | 1. Connectez-vous sur https://hub.docker.com/ 20 | 1. Cliquez sur Créer un référentiel. 21 | 1. Choisissez un nom (par exemple, verse_gapminder) et une description pour votre référentiel, puis cliquez sur Créer. 22 | 1. Connectez-vous au hub Docker à partir de la ligne de commande 23 | ```sh 24 | $ sudo docker login --username=yourhubusername --email=youremail@company.com 25 | ``` 26 | juste avec votre propre nom d'utilisateur et email que vous avez utilisé pour le compte. Entrez votre mot de passe lorsque vous y êtes invité. Si tout a fonctionné, vous recevrez un message similaire à 27 | ```sh 28 | WARNING: login credentials saved in /home/username/.docker/config.json 29 | Login Succeeded 30 | ``` 31 | 1. Vérifiez l'ID de l'image à l'aide de 32 | ```sh 33 | $ sudo docker images 34 | ``` 35 | and tag your image 36 | ```sh 37 | $ sudo docker tag bb38976d03cf yourhubusername/verse_gapminder:firsttry 38 | ``` 39 | Le numéro doit correspondre à l'ID de l'image et: firsttry correspond à la balise. En général, un bon choix pour une balise vous aidera à comprendre à quoi ce conteneur doit être associé ou ce qu’il représente. Si ce conteneur contient l’analyse d’un papier, envisagez d’utiliser le numéro DOI ou le numéro de série de ce journal; s’il est destiné à être utilisé avec une version particulière d’un référentiel de contrôle de version de code ou de données, c’est également un bon choix - tout ce qui vous aidera à comprendre le but de cette image particulière. 40 | 41 | 1. Poussez votre image dans le référentiel que vous avez créé 42 | ```sh 43 | $ sudo docker push yourhubusername/verse_gapminder 44 | ``` 45 | 46 | Votre image est maintenant disponible pour tout le monde. 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /Public-Repo/repo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Public-Repo/repo.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![](docker-logo.png) 2 | 3 | # docker-tutorials 4 | 5 | Vous trouverez ici: 6 | * les différents aspects du service Docker Container. En commençant par les bases de Docker qui se concentrent sur l’installation et la configuration de Docker, il aborde progressivement des sujets avancés tels que la mise en réseau et les registres. Les derniers chapitres de ce didacticiel couvrent les aspects de développement de Docker et vous expliquent comment vous pouvez être opérationnel sur les environnements de développement à l'aide de Docker Containers. 7 | 8 | # Vue d'ensemble 9 | 10 | Docker est un service de gestion de conteneurs. Les mots-clés de Docker sont développer, expédier et fonctionner n'importe où. Docker a pour principe de permettre aux développeurs de développer facilement des applications, de les envoyer dans des conteneurs pouvant ensuite être déployés n’importe où. 11 | * Caractéristiques de Docker: 12 | * Docker a la capacité de réduire la taille du développement en fournissant une empreinte plus petite du système d'exploitation via des conteneurs. 13 | * Avec les conteneurs, il est plus facile pour les équipes de différentes unités, telles que le développement, le contrôle qualité et les opérations, de travailler de manière transparente entre les applications. 14 | * Vous pouvez déployer des conteneurs Docker n'importe où, sur toutes les machines physiques et virtuelles et même sur le cloud. 15 | * Puisque les conteneurs Docker sont assez légers, ils sont très facilement évolutifs. 16 | * Composants de Docker: 17 | * Docker pour Mac - Il permet d’exécuter des conteneurs Docker sous Mac OS. 18 | * Docker pour Linux - Il permet d’exécuter des conteneurs Docker sur le système d’exploitation Linux. 19 | * Docker pour Windows - Il permet d’exécuter des conteneurs Docker sur le système d’exploitation Windows. 20 | * Docker Engine - Il est utilisé pour créer des images Docker et créer des conteneurs Docker. 21 | * Docker Hub - Il s'agit du registre utilisé pour héberger diverses images Docker. 22 | * Docker Compose - Ceci est utilisé pour définir des applications utilisant plusieurs conteneurs Docker. 23 | 24 | # Les chapitres 25 | 26 | * [Installer Docker sur Linux](Installation) 27 | * [Hub](Hub) 28 | * [Images](Images) 29 | * [Containers](Containers) 30 | * [Travailler avec des conteneurs](Pratiques) 31 | * [Architecture](Architecture) 32 | * [Container and Hosts](Container-hosts) 33 | * [Containers and Shells](Containers-Shells) 34 | * [Fichier](File) 35 | * [Construction de fichiers](Construction-fichiers) 36 | * [Dépôts publics](Public-Repo) 37 | * [Gestion des ports](Gestion-ports) 38 | * [Registres privés](Private-registers) 39 | * [Construction d'un fichier Docker de serveur Web](WebServer) 40 | * [Liaison de conteneur](Linking) 41 | * [Storage](Storage) 42 | * [Networking](Networking) 43 | * [Cloud](Cloud) 44 | * [Logging](Logging) 45 | * [Docker Compose](Compose) 46 | * [Intégration continue](CI) 47 | * [Architecture Kubernetes](KubernetesArchitecture) 48 | * [Fonctionnement de Kubernetes](Kubernetes) 49 | 50 | # Authors 51 | 52 | * [Roy Geagea](https://github.com/RoyGeagea) 53 | 54 | # Contribuer 55 | 56 | 1. Fork it () 57 | 2. Créez votre branche de fonctionnalité (`git checkout -b feature/fooBar`) 58 | 3. Commettez vos modifications (`git commit -am "Ajoutez du fooBar"`) 59 | 4. Push sur la branche (`git push origin feature/fooBar`) 60 | 5. Créer une nouvelle Pull Request 61 | 62 | # License 63 | 64 | This project is licensed under the GNU LESSER GENERAL PUBLIC License - see the [LICENSE](LICENSE) file for details 65 | 66 | 67 | -------------------------------------------------------------------------------- /Storage/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Storage/.DS_Store -------------------------------------------------------------------------------- /Storage/README.md: -------------------------------------------------------------------------------- 1 | # Storage 2 | 3 | ## Storage Drivers 4 | Docker dispose de plusieurs pilotes de stockage permettant de travailler avec les périphériques de stockage sous-jacents. Le tableau suivant répertorie les différents pilotes de stockage ainsi que la technologie utilisée pour les pilotes de stockage. 5 | 6 | ![](table.png) 7 | 8 | Parlons maintenant des cas dans lesquels vous utiliseriez les différents pilotes de stockage: 9 | 10 | * AUFS 11 | * C'est un pilote stable. peut être utilisé pour des applications prêtes à la production. 12 | * Il a une bonne utilisation de la mémoire et permet de garantir une expérience fluide de Docker pour les conteneurs. 13 | * Une activité d'écriture élevée associée à ce pilote doit être prise en compte. 14 | * C’est bon pour les systèmes qui fonctionnent comme une plate-forme. 15 | 16 | * Devicemapper 17 | * C'est un pilote stable. assure une expérience en douceur Docker. 18 | * Ce pilote est utile pour tester des applications en laboratoire. 19 | * Ce pilote correspond aux principales fonctionnalités du noyau Linux. 20 | 21 | * Btrfs 22 | * Ce pilote correspond aux principales fonctionnalités du noyau Linux. 23 | * Une activité d'écriture élevée associée à ce pilote doit être prise en compte. 24 | * Ce pilote convient aux instances dans lesquelles vous gérez plusieurs pools de construction. 25 | 26 | * Ovelay 27 | * Ce pilote est stable et conforme aux principales fonctionnalités du noyau Linux. 28 | * Il a une bonne utilisation de la mémoire. 29 | * Ce pilote est utile pour tester des applications en laboratoire. 30 | 31 | * ZFS 32 | * C'est un pilote stable et il est bon pour tester des applications en laboratoire. 33 | * C’est bon pour les systèmes fonctionnant comme une plate-forme en tant que service. 34 | 35 | Pour voir le pilote de stockage utilisé, lancez la commande docker info. 36 | ```sh 37 | $ sudo docker info 38 | ``` 39 | Output: 40 | 41 | La sortie suivante montre que le pilote principal utilisé dans le répertoire racine stocké dans /var/lib/docker. 42 | 43 | ![](info.png) 44 | 45 | ## Volumes de données 46 | Dans Docker, vous disposez d'un volume séparé pouvant être partagé entre plusieurs conteneurs. Celles-ci sont appelées volumes de données. Certaines des caractéristiques du volume de données sont: 47 | * Ils sont initialisés lors de la création du conteneur. 48 | * Ils peuvent être partagés et réutilisés entre plusieurs conteneurs. 49 | * Toute modification du volume lui-même peut être effectuée directement. 50 | * Ils existent même après la suppression du conteneur. 51 | 52 | Regardons notre conteneur Jenkins. Faisons un docker inspecter pour voir les détails de cette image. Nous pouvons émettre la commande suivante pour écrire le résultat de la commande docker inspect dans un fichier texte, puis afficher le fichier en conséquence. 53 | ```sh 54 | $ sudo docker inspect Jenkins > tmp.txt 55 | ``` 56 | Lorsque vous affichez le fichier texte à l'aide de la commande more, vous verrez une entrée sous la forme JENKINS_HOME=/var/Jenkins_home. 57 | 58 | Supposons maintenant que vous vouliez mapper le volume du conteneur sur un volume local, puis vous devez spécifier l'option –v lors du lancement du conteneur. Un exemple est montré ci-dessous: 59 | ```sh 60 | $ sudo docker run –d –v /home/demo:/var/jenkins_home –p 8080:8080 –p 50000:50000 jenkins 61 | ``` 62 | L'option –v est utilisée pour mapper le volume dans le conteneur /var/jenkins_home vers un emplacement de notre hôte Docker qui est /home/demo. 63 | 64 | ## Modification du pilote de stockage pour un conteneur 65 | Si vous souhaitez modifier le pilote de stockage utilisé pour un conteneur, vous pouvez le faire lors du lancement du conteneur. Cela peut être fait en utilisant le paramètre –volume-driver lors de l'utilisation de la commande docker run. Un exemple est donné ci-dessous: 66 | ```sh 67 | $ sudo docker run –d –volume-driver=flocker –v /home/demo:/var/jenkins_home –p 8080:8080 –p 50000:50000 jenkins 68 | ``` 69 | L'option –volume-driver permet de spécifier un autre pilote de stockage pour le conteneur. 70 | 71 | ## Créer un volume 72 | Un volume peut être créé à l’avance à l’aide de la commande docker. Apprenons-en plus sur cette commande. 73 | ```sh 74 | $ sudo docker volume create –-name=volumename –-opt options 75 | ``` 76 | * name - Ceci est le nom du volume à créer. 77 | * opt - Ce sont des options que vous pouvez fournir lors de la création du volume. 78 | 79 | ## Liste de tous les volumes 80 | ```sh 81 | $ sudo docker volume ls 82 | ``` 83 | 84 | Output: 85 | 86 | ![](volumelist.png) 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | -------------------------------------------------------------------------------- /Storage/info.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Storage/info.png -------------------------------------------------------------------------------- /Storage/table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Storage/table.png -------------------------------------------------------------------------------- /Storage/tmp.txt: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "Id": "sha256:cd14cecfdb3a657ba7d05bea026e7ac8b9abafc6e5c66253ab327c7211fa6281", 4 | "RepoTags": [ 5 | "jenkins:latest" 6 | ], 7 | "RepoDigests": [ 8 | "jenkins@sha256:eeb4850eb65f2d92500e421b430ed1ec58a7ac909e91f518926e02473904f668" 9 | ], 10 | "Parent": "", 11 | "Comment": "", 12 | "Created": "2018-07-17T16:20:34.183816595Z", 13 | "Container": "a3e3890f6333066d464113032a93622a8a12305fa1cf7a29e57ad29cbde66a19", 14 | "ContainerConfig": { 15 | "Hostname": "a3e3890f6333", 16 | "Domainname": "", 17 | "User": "jenkins", 18 | "AttachStdin": false, 19 | "AttachStdout": false, 20 | "AttachStderr": false, 21 | "ExposedPorts": { 22 | "50000/tcp": {}, 23 | "8080/tcp": {} 24 | }, 25 | "Tty": false, 26 | "OpenStdin": false, 27 | "StdinOnce": false, 28 | "Env": [ 29 | "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", 30 | "LANG=C.UTF-8", 31 | "JAVA_HOME=/docker-java-home", 32 | "JAVA_VERSION=8u171", 33 | "JAVA_DEBIAN_VERSION=8u171-b11-1~deb9u1", 34 | "CA_CERTIFICATES_JAVA_VERSION=20170531+nmu1", 35 | "JENKINS_HOME=/var/jenkins_home", 36 | "JENKINS_SLAVE_AGENT_PORT=50000", 37 | "TINI_VERSION=0.14.0", 38 | "TINI_SHA=6c41ec7d33e857d4779f14d9c74924cab0c7973485d2972419a3b7c7620ff5fd", 39 | "JENKINS_VERSION=2.60.3", 40 | "JENKINS_UC=https://updates.jenkins.io", 41 | "JENKINS_UC_EXPERIMENTAL=https://updates.jenkins.io/experimental", 42 | "COPY_REFERENCE_FILE_LOG=/var/jenkins_home/copy_reference_file.log" 43 | ], 44 | "Cmd": [ 45 | "/bin/sh", 46 | "-c", 47 | "#(nop) COPY file:a4f750618f51f00d2f8268ac43fdd8d8ef5ce16e1d412afa5a9bc7492a5d975f in /usr/local/bin/install-plugins.sh " 48 | ], 49 | "ArgsEscaped": true, 50 | "Image": "sha256:9e1d90142b1a1b659fae5d4b6427c3196495b24006ac29943aac019390bdd5d1", 51 | "Volumes": { 52 | "/var/jenkins_home": {} 53 | }, 54 | "WorkingDir": "", 55 | "Entrypoint": [ 56 | "/bin/tini", 57 | "--", 58 | "/usr/local/bin/jenkins.sh" 59 | ], 60 | "OnBuild": [], 61 | "Labels": {} 62 | }, 63 | "DockerVersion": "17.06.2-ce", 64 | "Author": "", 65 | "Config": { 66 | "Hostname": "", 67 | "Domainname": "", 68 | "User": "jenkins", 69 | "AttachStdin": false, 70 | "AttachStdout": false, 71 | "AttachStderr": false, 72 | "ExposedPorts": { 73 | "50000/tcp": {}, 74 | "8080/tcp": {} 75 | }, 76 | "Tty": false, 77 | "OpenStdin": false, 78 | "StdinOnce": false, 79 | "Env": [ 80 | "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", 81 | "LANG=C.UTF-8", 82 | "JAVA_HOME=/docker-java-home", 83 | "JAVA_VERSION=8u171", 84 | "JAVA_DEBIAN_VERSION=8u171-b11-1~deb9u1", 85 | "CA_CERTIFICATES_JAVA_VERSION=20170531+nmu1", 86 | "JENKINS_HOME=/var/jenkins_home", 87 | "JENKINS_SLAVE_AGENT_PORT=50000", 88 | "TINI_VERSION=0.14.0", 89 | "TINI_SHA=6c41ec7d33e857d4779f14d9c74924cab0c7973485d2972419a3b7c7620ff5fd", 90 | "JENKINS_VERSION=2.60.3", 91 | "JENKINS_UC=https://updates.jenkins.io", 92 | "JENKINS_UC_EXPERIMENTAL=https://updates.jenkins.io/experimental", 93 | "COPY_REFERENCE_FILE_LOG=/var/jenkins_home/copy_reference_file.log" 94 | ], 95 | "Cmd": null, 96 | "ArgsEscaped": true, 97 | "Image": "sha256:9e1d90142b1a1b659fae5d4b6427c3196495b24006ac29943aac019390bdd5d1", 98 | "Volumes": { 99 | "/var/jenkins_home": {} 100 | }, 101 | "WorkingDir": "", 102 | "Entrypoint": [ 103 | "/bin/tini", 104 | "--", 105 | "/usr/local/bin/jenkins.sh" 106 | ], 107 | "OnBuild": [], 108 | "Labels": null 109 | }, 110 | "Architecture": "amd64", 111 | "Os": "linux", 112 | "Size": 695718055, 113 | "VirtualSize": 695718055, 114 | "GraphDriver": { 115 | "Data": { 116 | "LowerDir": "/var/lib/docker/overlay2/7e8f644d1311cb945faa0c740fea97180ee53e41307874d0c3d27fa6dce8f644/diff:/var/lib/docker/overlay2/952429c55f4d3539a2a57cdb28450ef9afc66fd34b183e3c8d2a96f423d6c36a/diff:/var/lib/docker/overlay2/850e1a39b48b9ef17c315867d18041b790394fe2375a10e71c0861f517ae2da3/diff:/var/lib/docker/overlay2/f365222a31e1091258a166ff6739797337469e59d3b863b9104818735ce42624/diff:/var/lib/docker/overlay2/57097f95291f8fd635746e100ca3b5ed9e63e43ff89adcd84cc71e9d0ebd81d1/diff:/var/lib/docker/overlay2/0f81f5c593916acfa953bb55405e857ac4d7d71e4acf4c13b27c240ec01c7cfb/diff:/var/lib/docker/overlay2/70c3255ac7c1776ab4c17878bcdb8d08b192fbcbf5028c1715b262bf089e6f52/diff:/var/lib/docker/overlay2/4c90daf8d1e887f0cdb5e152c30ff023a450de41c6c8b9b82fde75698b601918/diff:/var/lib/docker/overlay2/8ab0226ab5220dfbfe8a3d6285653e92f14447932b02d72b47a136211c96bcfd/diff:/var/lib/docker/overlay2/4c6082208adf2d747029ab79a9bc63d66441a159a66d00a75942e029589e0bf4/diff:/var/lib/docker/overlay2/de6c4af921f1dc888972c44538853a1ef8a44fdc8e7cb79cc61cc4f488554d1b/diff:/var/lib/docker/overlay2/19e7eb674573cf805a50591ff592bab61850625e744a192814b1d5b38706041b/diff:/var/lib/docker/overlay2/ed193eb784edcd6f67779c1402841fbf0f734bb04e98a91947f335f7b5a9349a/diff:/var/lib/docker/overlay2/6fb74252f69b7f77e7dea3d09c1f846d407a44f740f070e00e4b25788f835c86/diff:/var/lib/docker/overlay2/5dabef8487a16a37b7ac3730e952404234e922743ac8f44ca3a39df0fd7d5f0f/diff:/var/lib/docker/overlay2/df3236c25fc0f7bfb7116875c68fb5b5f45bc92d368938d1b72581c027301b92/diff:/var/lib/docker/overlay2/42d49dc0505b2b91cf023caa747e375ec387d68e96603eebc458d071d87d34a0/diff:/var/lib/docker/overlay2/a37e66ece07f8015d8a13f292604035c1baf5dded272383facbbcb27ec94a2b7/diff:/var/lib/docker/overlay2/2af65fab34126d5245314a0e79b9da96212c11947236c6cc41f2db102846d31a/diff", 117 | "MergedDir": "/var/lib/docker/overlay2/04ee7e2ab4f2a2782c2badddd3525239c45967bb19aac0f90178a50c61170b3b/merged", 118 | "UpperDir": "/var/lib/docker/overlay2/04ee7e2ab4f2a2782c2badddd3525239c45967bb19aac0f90178a50c61170b3b/diff", 119 | "WorkDir": "/var/lib/docker/overlay2/04ee7e2ab4f2a2782c2badddd3525239c45967bb19aac0f90178a50c61170b3b/work" 120 | }, 121 | "Name": "overlay2" 122 | }, 123 | "RootFS": { 124 | "Type": "layers", 125 | "Layers": [ 126 | "sha256:3b10514a95bec77489a57d6e2fbfddb7ddfdb643907470ce5de0f1b05c603706", 127 | "sha256:719d45669b35360e3ca0d53d159c42ca9985eb925a6b28ac38d0ded39a1314e8", 128 | "sha256:ce6466f43b110e66d7d3a72600262a1f1b015d9a64aad5f133f081868d4825fc", 129 | "sha256:fa0c3f992cbd10a0569ed212414b50f1c35d97521f7e4a9e55a9abcf47ca77e2", 130 | "sha256:c477b6c8ca459c76222eb535faedb8979f4094552ac2a6cd56cb0f29262fdcfb", 131 | "sha256:9c2e8b91bfa88a95f732adec2bfc5c03fb40c535e6646ecf386235cdfb4e0e96", 132 | "sha256:c3ebb2aa7787555b542be6400d8064ae209a29d90c6e1b99ac5d02d5040392b4", 133 | "sha256:518c9e7eb3264c27c8d77b4d194c80d14373c5942c2da2e4409f062573139f1b", 134 | "sha256:571ae0d6961ab39851cdf93f5a753902cdd563d82e78cea54cbb6b0d420eb8f4", 135 | "sha256:9fe468dbb76f324cd4287ea7e32edf6fe0f8aa993776fc152a17ae4a9a68f948", 136 | "sha256:6ff38243bfb80a82749f0a954d1bd2faaa5673de4be5d5d9665100e2785fed40", 137 | "sha256:c19390bb619a105dd32e573b3a26765216ee27736304266909104607045b4779", 138 | "sha256:a0775f499ef138c2badd29831b31c28f4515c7802d0bde35111c8f8c7b60ed7d", 139 | "sha256:1db7316340117880a83816808041a1f9ea1848632ab72f51ce79fb60a6135e3e", 140 | "sha256:047f9c957a2e718be97e9928f1170d25e7dadd71737ca2a1e8e3db139c905915", 141 | "sha256:ceed640cbb9350a13ce3051520b59833fb2fc4bc05c69873792293a2a27a485c", 142 | "sha256:d51e4482f53a5764af588bea1c8dda817e968af11e7e2df3ae3051757e1dc533", 143 | "sha256:37c1d818eb0bf741290f4122d6ae95b1dffb1f544896b0089ad7789613fa8804", 144 | "sha256:b1891bf16fa79f6376941e4b2409d26f2c85e993de9ba3dcaee57dc80ac4d889", 145 | "sha256:0577e068c587d352efe5dd72477ae6927626840d167fbbf59e17241b8f50a127" 146 | ] 147 | }, 148 | "Metadata": { 149 | "LastTagTime": "0001-01-01T00:00:00Z" 150 | } 151 | } 152 | ] 153 | -------------------------------------------------------------------------------- /Storage/volumelist.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/Storage/volumelist.png -------------------------------------------------------------------------------- /WebServer/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM ubuntu 2 | RUN apt-get update 3 | RUN apt-get install –y apache2 4 | RUN apt-get install –y apache2-utils 5 | RUN apt-get clean 6 | EXPOSE 80 CMD [“apache2ctl”, “-D”, “FOREGROUND”] 7 | -------------------------------------------------------------------------------- /WebServer/README.md: -------------------------------------------------------------------------------- 1 | # Construction d'un fichier Docker de serveur Web 2 | 3 | Nous avons déjà appris à utiliser Docker File pour créer nos propres images personnalisées. Voyons maintenant comment créer une image de serveur Web pouvant être utilisée pour créer des conteneurs. 4 | 5 | Dans notre exemple, nous allons utiliser le serveur Web Apache sur Ubuntu pour créer notre image. Suivez les étapes ci-dessous pour construire notre fichier Docker de serveur Web. 6 | 7 | ## Étape 1 8 | La première étape consiste à créer notre fichier Docker. Utilisons vim et créons un fichier Docker avec les informations suivantes 9 | ```sh 10 | FROM ubuntu 11 | RUN apt-get update 12 | RUN apt-get install –y apache2 13 | RUN apt-get install –y apache2-utils 14 | RUN apt-get clean 15 | EXPOSE 80 CMD [“apache2ctl”, “-D”, “FOREGROUND”] 16 | ``` 17 | Les points suivants doivent être notés à propos des déclarations ci-dessus: 18 | * Nous créons d’abord notre image à partir de l’image de base Ubuntu. 19 | * Ensuite, nous allons utiliser la commande RUN pour mettre à jour tous les paquets sur le système Ubuntu. 20 | * Ensuite, nous utilisons la commande RUN pour installer apache2 sur notre image. 21 | * Nous utilisons ensuite la commande RUN pour installer les packages d’utilitaires apache2 nécessaires sur notre image. 22 | * Ensuite, nous utilisons la commande RUN pour nettoyer tous les fichiers inutiles du système. 23 | * La commande EXPOSE permet d’exposer le port 80 d’Apache du conteneur à l’hôte Docker. 24 | * Enfin, la commande CMD est utilisée pour exécuter apache2 en arrière-plan. 25 | 26 | ## Étape 2 27 | Exécutez la commande de compilation Docker pour générer le fichier Docker. Cela peut être fait en utilisant la commande suivante 28 | ```sh 29 | $ sudo docker build -t mywebserver . 30 | ``` 31 | 32 | ## Étape 3 33 | Le fichier du serveur Web étant maintenant créé, il est maintenant temps de créer un conteneur à partir de l'image. Nous pouvons le faire avec la commande d'exécution Docker. 34 | ```sh 35 | $ sudo docker run –d –p 80:80 mywebserver 36 | ``` 37 | 38 | If you go to port 80 of the Docker host in your web browser, you will now see that Apache is up and running. 39 | 40 | ![](webpage.png) 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /WebServer/webpage.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/WebServer/webpage.png -------------------------------------------------------------------------------- /_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-architect 2 | 3 | author: Roy Geagea 4 | 5 | author_email: roygeagea@gmail.com 6 | 7 | title: Autour de Docker 8 | 9 | plugins: 10 | - jekyll-sitemap 11 | -------------------------------------------------------------------------------- /docker-logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RoyGeagea/docker-tutorials/96846abf2249151402df4c0c315ffd401173d099/docker-logo.png --------------------------------------------------------------------------------