Sprache des Docker-Wals anpassen

Einführung

Ahoy, Docker-Sprachenkünstler! Du hast es geschafft, den Docker-Wal zu sprechen zu bringen, aber kannst du ihn auch mehrsprachig machen? In dieser Herausforderung wirst du ein Docker-Image erstellen, das Umgebungsvariablen nutzt, um die Sprache der Begrüßung des Wals zu ändern. Mach dich bereit, unserem walartigen Freund eine globale Stimme zu verleihen!

Skills Graph

Erstelle einen vielsprachigen Wal

Stell dir vor, du entwickelst eine mehrsprachige Anwendung und musst deine Docker-Konfiguration schnell in verschiedenen Sprachumgebungen testen. Hier kommt unser vielsprachiger Wal ins Spiel!

In dieser Herausforderung wirst du deine Docker-Fähigkeiten auf die nächste Stufe heben, indem du einen flexiblen, sprachbewussten Container erstellst. Du wirst Umgebungsvariablen – ein leistungsstarkes Werkzeug im Docker-Ökosystem – nutzen, um die Sprache der Begrüßung unseres freundlichen Docker-Wals dynamisch zu ändern.

Bevor wir einsteigen, richten wir deine Herausforderungsumgebung ein. Navigiere im Terminal in das Verzeichnis ~/project/docker. Dort findest du einige Starterdateien, die dir dein Docker-Mentor zur Verfügung gestellt hat. Diese Dateien geben dir einen guten Start und ermöglichen es dir, dich auf die Kernkonzepte dieser Herausforderung zu konzentrieren.

Bist du bereit, unserem walartigen Freund eine globale Stimme zu verleihen? Lass uns Wellen in der Welt der mehrsprachigen Container schlagen!

Aufgaben

Deine sprachliche Mission, falls du sie annimmst, besteht darin:

1. Das bereitgestellte Skript entrypoint.sh zu untersuchen, um zu verstehen, wie es verschiedene Sprachen verarbeitet.
2. Die Dockerfile so zu ändern, dass das entrypoint.sh-Skript integriert und Umgebungsvariablen eingerichtet werden.
3. Ein Docker-Image aus deiner fertiggestellten Dockerfile zu erstellen.
4. Container aus deinem Image auszuführen und mit verschiedenen Spracheinstellungen zu experimentieren.

Anforderungen

Um diese Herausforderung erfolgreich abzuschließen, musst du:

1. docker/whalesay als Basisimage in deiner Dockerfile verwenden.
2. In deiner Dockerfile eine Umgebungsvariable namens WHALE_LANGUAGE mit einem Standardwert von "English" erstellen.
3. Das bereitgestellte entrypoint.sh-Skript korrekt in dein Image kopieren und es als Einstiegspunkt festlegen.
4. Dein Image mit dem Tag polyglot-whale erstellen.
5. Deinen Container mit der Umgebungsvariablen so einstellen, dass der Wal sowohl Englisch als auch Spanisch spricht.
6. Alle Befehle im Verzeichnis ~/project/docker ausführen.

Denke daran, dass das entrypoint.sh-Skript bereits für dich bereitgestellt wird. Deine Hauptaufgabe besteht darin, eine Dockerfile zu erstellen, die dieses Skript richtig nutzt und eine Sprachanpassung über Umgebungsvariablen ermöglicht.

Beispiel

Wenn du deinen Container mit ausgewählter spanischer Sprache ausführst, solltest du eine Ausgabe ähnlich dieser sehen:

docker run -e WHALE_LANGUAGE=Spanish polyglot-whale

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

Und wenn du ihn mit der Standard-Einstellung auf Englisch ausführst:

docker run polyglot-whale

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

Zusammenfassung

In dieser Herausforderung hast du deine Docker-Fähigkeiten erweitert, indem du ein Image erstellt hast, das Umgebungsvariablen zur Konfiguration nutzt. Du hast gelernt, wie man:

1. Umgebungsvariablen in einer Dockerfile verwendet, um Standardwerte festzulegen.
2. Ein einfaches Shell-Skript erstellt, das als Einstiegspunkt für deinen Container dient.
3. Umgebungsvariablen beim Ausführen eines Containers überschreibt.

Diese Fähigkeiten sind von entscheidender Bedeutung für die Erstellung flexibler, konfigurierbarer Docker-Images, die sich an verschiedene Umgebungen oder Anwendungsfälle anpassen können. Wenn du deine Docker-Reise fortsetzt, denke daran, dass Umgebungsvariablen ein leistungsstarkes Werkzeug sind, um deine Container vielseitiger und einfacher in verschiedenen Bereitstellungsszenarien zu verwalten. Bleib neugierig und viel Spaß beim Wal-Sprechen!