Personnaliser la langue de la baleine Docker

Introduction

Ohé, linguiste de Docker ! Vous maîtrisez déjà l'art de faire parler la baleine Docker, mais saurez-vous la rendre multilingue ? Dans ce défi, vous allez créer une image Docker utilisant des variables d'environnement pour changer la langue des salutations de la baleine. Préparez-vous à donner une voix internationale à notre amie cétacée !

Créer une baleine polyglotte

Imaginez que vous développiez une application multilingue et que vous ayez besoin d'un moyen rapide pour tester votre configuration Docker dans différents environnements linguistiques. C'est là qu'intervient notre baleine polyglotte !

Dans ce défi, vous allez franchir une nouvelle étape dans vos compétences Docker en créant un conteneur flexible et sensible à la langue. Vous utiliserez les variables d'environnement — un outil puissant de l'écosystème Docker — pour modifier dynamiquement la langue de salut de notre sympathique baleine Docker.

Avant de plonger, préparons votre environnement de travail. Rendez-vous dans le répertoire ~/project/docker de votre terminal. Vous y trouverez quelques fichiers de base fournis par votre mentor Docker. Ces fichiers vous donneront une longueur d'avance, vous permettant de vous concentrer sur les concepts fondamentaux de ce défi.

Prêt à donner une voix mondiale à notre amie des océans ? C'est parti pour faire des vagues dans le monde des conteneurs multilingues !

Tâches

Votre mission linguistique, si vous l'acceptez, consiste à :

1. Examiner le script entrypoint.sh fourni pour comprendre comment il gère les différentes langues.
2. Modifier le Dockerfile pour y intégrer le script entrypoint.sh et configurer les variables d'environnement.
3. Construire une image Docker à partir de votre Dockerfile complété.
4. Exécuter des conteneurs à partir de votre image en expérimentant différents paramètres de langue.

Exigences

Pour réussir ce défi, vous devez :

1. Utiliser docker/whalesay comme image de base dans votre Dockerfile.
2. Créer une variable d'environnement nommée WHALE_LANGUAGE dans votre Dockerfile, avec une valeur par défaut fixée à "English".
3. Utiliser l'instruction COPY dans votre Dockerfile pour copier le script entrypoint.sh fourni vers le répertoire racine (/) de votre image, en le nommant /entrypoint.sh. Assurez-vous qu'il possède les permissions d'exécution et définissez-le comme ENTRYPOINT.
4. Construire votre image avec le tag polyglot-whale.
5. Exécuter votre conteneur en configurant la variable d'environnement pour que la baleine parle à la fois anglais et espagnol.
6. Exécuter toutes les commandes dans le répertoire ~/project/docker.

Rappelez-vous que le script entrypoint.sh vous est déjà fourni. Votre tâche principale est de créer un Dockerfile qui utilise correctement ce script et permet la personnalisation de la langue via les variables d'environnement.

Exemple

Lorsque vous lancez votre conteneur avec l'espagnol sélectionné, vous devriez voir un résultat similaire à celui-ci :

docker run -e WHALE_LANGUAGE=Spanish polyglot-whale

 _________
< ¡Hola! >
 ---------
    \
     \
      \
                    ###        .
              ### ### ###       ==
           ### ### ### ###      ===
       /""""""""""""""""___/ ===
  ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
       \______ o          __/
        \    \        __/
          \____\______/

Et lors de l'exécution avec le paramètre par défaut en anglais :

docker run polyglot-whale

 _________
< Hello! >
 ---------
    \
     \
      \
                    ###        .
              ### ### ###       ==
           ### ### ### ###      ===
       /""""""""""""""""___/ ===
  ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
       \______ o          __/
        \    \        __/
          \____\______/

Résumé

Dans ce défi, vous avez approfondi vos compétences Docker en créant une image qui utilise des variables d'environnement pour sa configuration. Vous avez appris à :

1. Utiliser des variables d'environnement dans un Dockerfile pour définir des valeurs par défaut.
2. Créer un script shell simple pour servir de point d'entrée (entrypoint) à votre conteneur.
3. Surcharger les variables d'environnement lors de l'exécution d'un conteneur.

Ces compétences sont essentielles pour créer des images Docker flexibles et configurables, capables de s'adapter à différents environnements ou cas d'utilisation. Tout au long de votre parcours Docker, gardez à l'esprit que les variables d'environnement sont un outil puissant pour rendre vos conteneurs plus polyvalents et plus faciles à gérer dans divers scénarios de déploiement. Continuez vos explorations et bonne conversation avec la baleine !