Docker: Facile à construire, exécuter, c'est fait!

Docker a fait beaucoup de bruit récemment, et pour une bonne raison. Le service de conteneurisation rend le déploiement de microservices simple et stable, car chaque service peut exécuter un système d'exploitation dans son propre environnement virtuel. Cela signifie une compatibilité totale ... plus besoin de vous soucier des versions d'OS, des dépendances et des différences entre vos machines de développement et de production! Et pour couronner le tout, il est léger afin que vous puissiez exécuter plusieurs conteneurs Docker dans la même machine (instance EC2). Aujourd'hui, nous allons apprendre comment configurer et déployer Docker sur Amazon EC2 en 3 étapes faciles!

Avant de commencer, jetez un œil à ce diagramme de haut niveau (gracieuseté de infoworld.com).

Sur le côté gauche se trouve la configuration de votre machine virtuelle traditionnelle à l'aide d'un hyperviseur. Un hyperviseur est simplement votre gestionnaire de VM responsable de l'allocation des ressources matérielles à chaque système d'exploitation virtuel. Si chaque système d'exploitation invité a besoin de 1 Go de mémoire et que l'hôte utilise 1 Go de mémoire, la configuration de gauche nécessiterait un total de 4 Go.

Sur le côté droit se trouve une configuration de conteneur, qui exécuterait un moteur de conteneur tel que Docker. La différence la plus significative est qu'un moteur de conteneur est plus léger car il peut partager certaines ressources matérielles avec son système d'exploitation hôte, contrairement aux machines virtuelles traditionnelles qui nécessitent leur propre allocation distincte. Cette configuration nécessite 1 Go pour le système d'exploitation hôte et peut-être 600 Mo par conteneur (car 300 Mo sont hypothétiquement partagés avec le système d'exploitation hôte), pour un total de 2,8 Go requis. Vous voyez ces avantages? Cool, maintenant nous pouvons commencer!

Commencer

Entrez votre instance EC2 et clonez Kangzeroos-ES6-React-Redux-Boilerplate depuis Github. Le code que vous voyez servira à configurer cette application Web, mais les étapes sont les mêmes pour tous les projets. Une fois que vous l'avez téléchargé, allez dans le dossier et trouvez les fichiers ci-dessous. Ce sont les fichiers que nous utiliserons avec Docker.

Dockerfile build.sh run.sh

Avant de pouvoir utiliser Docker, nous devons d'abord l'installer. Vous trouverez ci-dessous le moyen rapide et simple d'installer Docker, mais si vous voulez la configuration complète, consultez la documentation officielle.

$ sudo apt-get update $ sudo apt-get install docker-engine $ sudo service docker start $ sudo docker run hello-world

La dernière commande vérifie si Docker s'exécute avec succès, puis se ferme. Si tout cela fonctionne, vous êtes prêt à démarrer Dockerizing!

Étape 1: création du fichier Dockerfile

La première étape consiste à configurer les fichiers nécessaires à Docker pour se créer une image. Les images Docker sont simplement des plans d'environnements que vous souhaitez créer tandis que les conteneurs sont les environnements fonctionnels et fonctionnels dans lesquels votre application sera exécutée. À la racine de notre répertoire d'applications, il y a un dossier appelé App. L'application Web elle-même réside dans ce Appdossier, tandis que tous les éléments liés à Docker sont à l'extérieur. Cela est nécessaire car Docker conteneurisera tout ce qu'il contient App. Faisons donc le premier fichier Docker appelé Dockerfile(pas d'extension de fichier Dockerfile.sh, juste Dockerfile) et parcourons-le ligne par ligne.

FROM ubuntu # ubuntu setup RUN apt-get update -y RUN apt-get upgrade -y RUN apt-get install nodejs -y && apt-get install npm -y # install curl for n RUN apt-get install curl -y RUN apt-get install vim -y # obtain latest stable version of node RUN npm cache clean -f RUN npm install -g n RUN n stable # setup working directory # ADD /App /App WORKDIR /App RUN npm install # expose port EXPOSE 8080

La première ligne est FROM ubuntu. Le but de Dockerfileest de configurer le système d'exploitation et les programmes dans le système d'exploitation, il est donc logique que la première ligne spécifie la version du système d'exploitation à utiliser. ubuntuici fait référence à une image spécifique hébergée sur Docker Hub, en particulier l'image officielle du système d'exploitation Ubuntu.

# ubuntu setup RUN apt-get update -y RUN apt-get upgrade -y RUN apt-get install curl -y RUN apt-get install vim -y

Le prochain ensemble de lignes est configuré dans Ubuntu. Nous voulons vérifier les mises à jour d'Ubuntu avec RUN apt-get update -yet les mises à niveau avec RUN apt-get upgrade -y… des éléments assez standard pour configurer votre environnement. Installez également curl RUN apt-get install curl -yet vim RUN apt-get install vim -y, tous deux agréables à utiliser à des fins générales.

# obtain latest stable version of node RUN apt-get install nodejs -y && apt-get install npm -y RUN npm cache clean -f RUN npm install -g n RUN n stable

Le prochain ensemble de lignes est une configuration spécifique à NodeJS. Puisque nous voulons utiliser les fonctionnalités ES6, nous aurons besoin de la dernière version de NodeJS obtenue via le module node n. Installez NodeJS et NPM avec RUN apt-get install nodejs -y && apt-get install npm -y. Ensuite, nettoyez npm pour faire place à l' nutilisation RUN npm cache clean -f. Installez navec RUN npm install -g n. Et enfin, nous pouvons exécuter n(dernière version de NodeJS) avec RUN n stable.

NodeJS est pour Javascript, mais si vous travailliez avec d'autres langages tels que Python, vous installeriez tous les programmes dont vous avez besoin pour exécuter votre application Python.

# setup working directory ADD /App /App WORKDIR /App RUN npm install # expose port EXPOSE 8080

La dernière partie Dockerfileconsiste à configurer le répertoire de travail de l'application elle-même. ADD /App /Appprend le Appdossier de notre machine et le copie dans le conteneur Docker. Ensuite, WORKDIR /Appdéfinissez le répertoire de travail Docker sur /Appafin que toutes les commandes que vous exécutez dans Docker soient exécutées dans /App. Ceci est nécessaire pour npm installinstaller au bon endroit (aka /Appdu conteneur Docker).

Enfin, nous RUN npm installqui installe nos dépendances NodeJS dans notre machine. Enfin, nous exposerons explicitement le port 8080 de notre image Docker avec EXPOSE 8080afin que le monde extérieur puisse accéder à notre application. Le monde extérieur comprend Internet ainsi que d'autres conteneurs Docker fonctionnant sur la même machine.

Étape 2: Le script de construction

docker build -t kangzeroo .

Créez un nouveau fichier dans le répertoire racine de votre application appelé build.sh. Il s'agit d'un fichier shell pour la construction de notre conteneur Docker. Ce build.shfichier n'est pas réellement nécessaire car nous pouvons exécuter directement cette commande dans le terminal. Cependant, c'est vraiment bien pour simplifier le processus.

Voici la répartition de cette ligne: docker buildest la commande qui indique à Docker de créer une image. -t kangzeroodéfinit le nom de balise de l'image Docker kangzeroo, que nous pourrons référencer ultérieurement. Veuillez noter que pour avoir un nom de balise valide, il doit être en minuscules et sans espace (utilisez la dénomination en cas de serpent). Enfin, .indique à Docker où rechercher les éléments Dockerfilenécessaires à la construction (c'est-à- .dire ici).

Si vous êtes dans une instance EC2, nous pouvons exécuter à bash build.shpartir du répertoire racine de notre projet. Cela démarrera le processus de construction de Docker au fur et à mesure qu'il passera par les étapes de la Dockerfilecréation. Cela peut prendre un certain temps… à la fin, cela devrait ressembler à ceci: (Ne vous inquiétez pas des erreurs non critiques telles que la dépendance facultative ignorée dans la capture d'écran ci-dessous).

Vérifions maintenant si notre image a été créée. Tapez docker imagespour voir les images en cours d'exécution sur notre machine. Vous devriez voir un résultat comme celui-ci:

Si nous voulons supprimer cette image, tapez simplement docker rmi kangzeroo. Si vous tapez à docker imagesnouveau après la suppression, vous verrez que l'image n'est plus là. Pour l'instant, laissons l'image car nous allons l'utiliser pour créer le conteneur Docker dans lequel notre application s'exécutera.

Étape 3: Le script d'exécution

Now that our image has been created, let’s make run.sh. Recall that Docker Images are simply blueprints of environments that you want to create. Containers are the actual running and functional environments that your app will be executed in. So run.sh will turn our images into containers. Here is what run.sh looks like:

docker run -d -it -p 80:8080 --name=kz kangzeroo npm run ec2 -- --host=0.0.0.0

Let’s walkthrough this short script. docker run is the command to run a container from an image. -d -it is the command for daemon (running tasks in the background) and interactive terminal (giving us a way to interact with the container). If you omit -d then the docker container will not run in the background and you will see log output from the app. -p 80:8080 maps port 80 of our machine to port 8080 of the container. Recall that earlier we specified EXPOSE 8080 in our Dockerfile. So now we take incoming connections on our machine’s port 80 (port 80 is the default for http) and redirect them to our container’s port 8080. If your app is not a webpage, then you can exclude this port mapping.--name=kz gives our container the name kz. Finally, kangzeroo npm run ec2 refers to our image called kangzeroo and npm run ec2 is a command specific to this boilerplate app (for starting up the app). The last part — — host=0.0.0.0 sets the boilerplate to run on 0.0.0.0 instead of localhost (This too is specific to the boilerplate). If you were running a Python backend app, it would look like docker run -d -it --name=kz kangzeroo python app.py.

Great! Save this file and run it with bash run.sh. Then check if the container is running by typing docker ps -a. This is what it should look like:

Your app is now online and running inside a Docker container! Check if it works… for this boilerplate you can check from a web browser.

And it’s working! Great, now let’s turn off our Docker container. Type docker ps -a to see all the containers again. Type docker stop kz and it stops the container. If you type docker ps you will not see the container anymore, but you will see it if you type docker ps -a ( -a means all, inclusive of running and not running container. omit -a if you only want to see running containers). To remove the container, type docker rm kz. If you type docker ps -a you won’t see the container anymore.

Conclusion

C'était Docker! Tout bien considéré, Docker est beaucoup plus facile que de configurer une machine virtuelle basée sur un hyperviseur, et vous pouvez voir comment une architecture de microservice devient beaucoup plus facile à gérer lorsque vous adoptez des conteneurs. Avec nos Dockerfile, build.shet les run.shfichiers créés dans EC2, on peut résumer les 3 étapes à courir Docker de notre application répertoire racine:

$ bash build.sh $ bash run.sh $ exit

C'est ça! Docker: facile à construire, exécuter, terminé!

Bonus Cheatsheet

Étant donné que ce didacticiel a adopté une approche étape par étape pour enseigner Docker, je pense qu'il est approprié de vous laisser avec un aperçu de toutes les commandes Docker dont vous aurez besoin pour une utilisation générale.

$ docker images // To view install images $ docker rmi  // To remove an installed image $ docker ps -a // To view all docker containers $ docker stop  // To stop a docker container $ docker rm  // To remove a docker container $ docker exec -it  bash // Execute into container and run bash * If you want to see the log output from a docker container, omit the -d from run.sh
Ces méthodes ont été partiellement utilisées dans le déploiement de renthero.ca