1. Présentation
Docker est une plate-forme ouverte permettant de développer, de lancer et d'exécuter des applications. Avec cette solution, vous pouvez séparer les applications de votre infrastructure et traiter cette dernière comme une application gérée. Docker vous fait gagner du temps lors des phases de lancement, de test et de déploiement du code, et raccourcit le cycle entre la rédaction et l'exécution du code.
Pour ce faire, Docker combine des fonctionnalités de conteneurisation de noyau avec des workflows et des outils qui vous aident à gérer et à déployer vos applications.
Les conteneurs Docker peuvent être utilisés directement dans Kubernetes, ce qui permet de les exécuter facilement dans Kubernetes Engine. Après avoir découvert les principes de base de Docker, vous disposerez de toutes les compétences requises pour développer des applications Kubernetes et des applications conteneurisées.
Objectifs de l'atelier
Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :
- Créer un Dockerfile pour un exemple d'application
- Créer une image
- Exécuter l'image en tant que conteneur localement
- Modifier le comportement du conteneur
- Transférer l'image vers Artifact Registry
Prérequis
Cet atelier s'adresse aux débutants. Il ne nécessite aucune connaissance particulière de Docker ni des conteneurs. Une connaissance préalable de Cloud Shell et de la ligne de commande est recommandée, mais pas indispensable.
Configuration de l'environnement au rythme de chacun
- Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)
- Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères qui n'est pas utilisée par les API Google, et que vous pouvez modifier à tout moment.
- L'ID du projet doit être unique sur l'ensemble des projets Google Cloud et doit être immuable (vous ne pouvez pas le modifier une fois que vous l'avez défini). Cloud Console génère automatiquement une chaîne unique dont la composition importe peu, en général. Dans la plupart des ateliers de programmation, vous devrez référencer l'ID du projet (généralement identifié comme
PROJECT_ID), donc s'il ne vous convient pas, générez-en un autre au hasard ou définissez le vôtre, puis vérifiez s'il est disponible. Il est ensuite "gelé" une fois le projet créé. - La troisième valeur est le numéro de projet, utilisé par certaines API. Pour en savoir plus sur ces trois valeurs, consultez la documentation.
- Vous devez ensuite activer la facturation dans Cloud Console afin d'utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour arrêter les ressources afin d'éviter qu'elles ne vous soient facturées après ce tutoriel, suivez les instructions de nettoyage indiquées à la fin de l'atelier. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300$.
2. Exemple d'application
Un exemple d'application a été fourni pour faciliter cet atelier. Dans cette section, vous allez récupérer le code source et créer l'application dans son format natif avant de passer au processus de conteneurisation.
Code source
Le code source de cet atelier est disponible dans le dépôt GoogleCloudPlatform/container-developer-workshop, ainsi que dans la documentation de l'exemple d'application .
Configurer Git
git config --global user.name ${USER}
git config --global user.email ${USER}@qwiklabs.net
Cloner le dépôt Cloud Source Repositories de l'exemple d'application
gcloud source repos clone sample-app ${HOME}/sample-app &&
cd ${HOME}/sample-app &&
git checkout main
Sortie
Cloning into '/home/student_03_49720296e995/sample-app'... remote: Finding sources: 100% (16/16) remote: Total 16 (delta 0), reused 16 (delta 0) Receiving objects: 100% (16/16), 47.23 KiB | 681.00 KiB/s, done. warning: remote HEAD refers to nonexistent ref, unable to checkout. Project [qwiklabs-gcp-02-4327c4e03d82] repository [sample-app] was cloned to [/home/student_03_49720296e995/sample-app]. Branch 'main' set up to track remote branch 'main' from 'origin'. Switched to a new branch 'main'
Créer l'exemple d'application
cd ${HOME}/sample-app
./mvnw compile
Sortie
[INFO] Scanning for projects... ... [INFO] Compiling 1 source file to /home/student_03_49720296e995/sample-app/target/classes [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 10.080 s [INFO] Finished at: 2022-02-23T17:14:30Z [INFO] ------------------------------------------------------------------------
Exécuter l'exemple d'application
cd ${HOME}/sample-app
./mvnw exec:java
Sortie
[INFO] Scanning for projects... ... Listening at http://localhost:8080
Prévisualiser l'application en cours d'exécution
- Cliquez sur le bouton Aperçu sur le Web de Cloud Shell.
- Cliquez sur "Prévisualiser sur le port 8080".
Lorsque vous avez terminé
- Appuyez sur CTRL+C dans Cloud Shell pour arrêter l'application en cours d'exécution.
3. Dockerfile
Conteneuriser l'application avec un Dockerfile
L'une des méthodes permettant d'empaqueter une application dans un conteneur consiste à utiliser un Dockerfile. Le Dockerfile est semblable à un script qui indique au daemon comment assembler l'image de conteneur. Pour en savoir plus, consultez la documentation de référence sur Dockerfile.
Créez un Dockerfile vide dans le dépôt de l'exemple d'application.
touch ${HOME}/sample-app/Dockerfile
Ouvrez le Dockerfile dans l'éditeur de votre choix.
vi ${HOME}/sample-app/Dockerfile
Choisir une image de départ
Pour créer un conteneur à l'aide de la méthode Dockerfile, vous devez connaître directement l'application afin d'assembler le conteneur. La première étape de la création d'un Dockerfile consiste à sélectionner une image qui servira de base à votre image.Cette image doit être une image parent ou de base gérée et publiée par une source fiable, généralement votre entreprise.
L'instruction FROM initialise une nouvelle étape de compilation et définit l'image de base pour les commandes séquentielles suivantes. L'instruction FROM est donc généralement la première instruction d'un Dockerfile et ne peut être précédée que d'une instruction ARG facultative pour prendre en charge les variables.
Syntaxe : FROM <image>[:<tag> | @<digest>] [AS <name>]
Le format d'une image est <image>:<tag> ou <image>@<digest>. Si aucun tag ni résumé n'est spécifié, la valeur par défaut est le tag :latest. Le format de <image> varie en fonction du registre utilisé pour stocker l'image. Pour Artifact Registry, le <image> format est <region>-docker.pkg.dev/<project ID>/<repository name>/<image name>:<image tag>.
Pour cet atelier, nous utilisons l'image publique openjdk:11.0-jdk. Ajoutez la ligne suivante à votre Dockerfile :
FROM openjdk:11.0-jdk
Définir le répertoire de travail
L'instruction WORKDIR définit le répertoire de travail pour toutes les instructions séquentielles qui suivent dans le Dockerfile. Pour en savoir plus, consultez la section WORKDIR de la documentation de référence sur Dockerfile.
Syntaxe : WORKDIR <path>
Pour cet atelier, nous utilisons le répertoire /app comme WORKDIR. Ajoutez la ligne suivante au bas de votre Dockerfile :
WORKDIR /app
Copier les fichiers de l'application
L'instruction COPY copie des répertoires ou des fichiers de l'emplacement <source> vers le chemin <destination> du système de fichiers de l'image. Vous pouvez spécifier plusieurs ressources <source>, qui sont toutes relatives au contexte de compilation. Le contexte de compilation sera abordé plus en détail dans la section "Créer". Pour en savoir plus, consultez la section COPY de la documentation de référence sur Dockerfile.
Syntaxe : COPY <source>... <destination>
Pour cet atelier, nous allons copier tous les fichiers du dépôt dans le système de fichiers de l'image. Ajoutez la ligne suivante au bas de votre Dockerfile :
COPY . /app
Compiler l'application
L'instruction RUN exécute des commandes dans une nouvelle couche d'image au-dessus de l'image actuelle et valide les résultats. L'image validée obtenue sera utilisée pour les étapes séquentielles du Dockerfile. Pour en savoir plus, consultez la section RUN de la documentation de référence sur Dockerfile.
Syntaxe : RUN <command>
Pour cet atelier, nous allons utiliser Maven pour compiler l'application dans un fichier JAR. Ajoutez la ligne suivante au bas de votre Dockerfile :
RUN ./mvnw compile assembly:single
Démarrer l'application
L'instruction CMD fournit la commande par défaut pour un conteneur en cours d'exécution. Il ne peut y avoir qu'une seule instruction CMD dans un Dockerfile. Si plusieurs CMD sont spécifiées, seule la dernière CMD prendra effet. Des fonctionnalités plus avancées sont disponibles à l'aide des instructions CMD et ENTRYPOINT, mais elles ne sont pas abordées dans cet atelier. Pour en savoir plus, consultez la section CMD` de la documentation de référence sur Dockerfile.
Syntaxe : CMD ["executable","param1","param2"]
Pour cet atelier, nous exécutons le fichier JAR que nous avons compilé. Ajoutez la ligne suivante au bas de votre Dockerfile :
CMD ["java","-jar","/app/target/sample-app-1.0.0-jar-with-dependencies.jar"]
Dockerfile final
Le Dockerfile final sera
FROM openjdk:11.0-jdk
WORKDIR /app
COPY . /app
RUN ./mvnw compile assembly:single
CMD ["java","-jar","/app/target/sample-app-1.0.0-jar-with-dependencies.jar"]
Valider le Dockerfile localement
cd ${HOME}/sample-app
git add Dockerfile
git commit -m "Added Dockerfile"
4. Créer
Nous allons maintenant créer l'image à partir du Dockerfile à l'aide de la commande docker build. Cette commande indique au daemon Docker de créer l'image à l'aide des instructions de notre Dockerfile. Pour en savoir plus, consultez la documentation de référence sur docker build.
Créer l'image
cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker build --tag sample-app:${IMAGE_TAG} .
Sortie
Sending build context to Docker daemon 221.2kB Step 1/4 : FROM openjdk:11.0-jdk 11.0-jdk: Pulling from library/openjdk 0c6b8ff8c37e: Pull complete 412caad352a3: Pull complete e6d3e61f7a50: Pull complete 461bb1d8c517: Pull complete e442ee9d8dd9: Pull complete 542c9fe4a7ba: Pull complete 41de18d1833d: Pull complete Digest: sha256:d72b1b9e94e07278649d91c635e34737ae8f181c191b771bde6816f9bb4bd08a Status: Downloaded newer image for openjdk:11.0-jdk ---> 2924126f1829 Step 2/4 : WORKDIR /app ---> Running in ea037abb273d Removing intermediate container ea037abb273d ---> bd9b6d078082 Step 3/4 : COPY . /app ---> b9aec2b5de51 Step 4/4 : RUN ./mvnw compile jar:jar ---> Running in 3f5ff737b7fd [INFO] Scanning for projects... ... [INFO] Building jar: /app/target/sample-app-1.0.0.jar [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 22.952 s [INFO] Finished at: 2022-02-23T18:09:08Z [INFO] ------------------------------------------------------------------------ Removing intermediate container 331443caebd3 ---> 152f65cc441e Step 5/5 : CMD ["java", "-jar", "/app/target/sample-app-1.0.0.jar"] ---> Running in 3d595a72231c Removing intermediate container 3d595a72231c ---> 0e40d7548cab Successfully built 0e40d7548cab Successfully tagged sample-app:aaa8895
5. Exécuter
Une fois l'image de conteneur créée, nous pouvons exécuter notre application et nous assurer qu'elle se comporte comme prévu à l'aide de la commande docker run. Cette commande lance notre conteneur au premier plan de notre invite de commandes pour les tests ou le débogage. Pour en savoir plus, consultez la documentation de référence sur docker run.
Exécuter un conteneur à l'aide de l'image
cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
--rm \
-p 8080:8080 \
sample-app:${IMAGE_TAG}
Sortie
Listening at http://localhost:8080
Prévisualiser l'application en cours d'exécution dans un conteneur
- Cliquez sur le bouton Aperçu sur le Web de Cloud Shell.
- Cliquez sur "Prévisualiser sur le port 8080".
- Appuyez sur CTRL+C dans Cloud Shell pour arrêter les conteneurs.
Modifier le comportement du conteneur
L'exécution de Docker Run utilise la configuration par défaut du Dockerfile. Vous pouvez ajouter des instructions et des paramètres supplémentaires pour modifier ce comportement.
Activer la journalisation TRACE
cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
--rm \
-p 8080:8080 \
sample-app:${IMAGE_TAG} \
java -Dorg.slf4j.simpleLogger.defaultLogLevel=trace -jar /app/target/sample-app-1.0.0-jar-with-dependencies.jar
Prévisualiser l'application en cours d'exécution dans un conteneur
- Cliquez sur le bouton Aperçu sur le Web de Cloud Shell.
- Cliquez sur "Prévisualiser sur le port 8080".
- Basculez vers l'onglet Cloud Shell et constatez que la journalisation supplémentaire
- Appuyez sur CTRL+C dans Cloud Shell pour arrêter le conteneur.
Modifier le port
cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
--rm \
-e PORT=8081 \
-p 8081:8081 \
sample-app:${IMAGE_TAG}
Prévisualiser l'application en cours d'exécution dans un conteneur
- Cliquez sur le bouton Aperçu sur le Web de Cloud Shell.
- Cliquez sur "Modifier le port".
- Saisissez 8081.
- Cliquez sur "Modifier et prévisualiser".
- Appuyez sur CTRL+C dans Cloud Shell pour arrêter le conteneur.
6. Push
Une fois que nous sommes certains que l'image de conteneur s'exécute correctement et que nous voulons rendre ce conteneur disponible pour qu'il s'exécute dans d'autres environnements et/ou par d'autres utilisateurs, nous devons transférer l'image vers un dépôt partagé. Cela doit se produire dans le cadre d'un pipeline de compilation automatisé, mais dans notre environnement de test, nous avons déjà configuré un dépôt et nous pouvons transférer manuellement notre image.
Transférer la validation du Dockerfile vers le dépôt sample-app
cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
git push
Taguer l'image pour Artifact Registry
docker tag sample-app:${IMAGE_TAG} \
us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/apps/sample-app:${IMAGE_TAG}
Configurer vos identifiants pour Artifact Registry
gcloud auth configure-docker us-central1-docker.pkg.dev
Lorsque vous êtes invité à répondre à la question Do you want to continue (Y/n)?, répondez y et appuyez sur Enter.
Transférer l'image vers Artifact Registry
docker push us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/apps/sample-app:${IMAGE_TAG}
Sortie
The push refers to repository [us-central1-docker.pkg.dev/qwiklabs-gcp-04-b47ced695a3c/apps/sample-app] 453b97f86449: Pushed e86791aa0382: Pushed d404c7ee0850: Pushed fe4f44af763d: Pushed 7c072cee6a29: Pushed 1e5fdc3d671c: Pushed 613ab28cf833: Pushed bed676ceab7a: Pushed 6398d5cccd2c: Pushed 0b0f2f2f5279: Pushed aaa8895: digest: sha256:459de00f86f159cc63f98687f7c9563fd65a2eb9bcc71c23dda3351baf13607a size: 2424
7. Félicitations !
Félicitations, vous avez terminé cet atelier de programmation.
Points abordés
- Création d'un Dockerfile pour un exemple d'application
- Création d'une image
- Exécution de l'image en tant que conteneur localement
- Modification du comportement du conteneur
- Transfert de l'image vers Artifact Registry