1. Panoramica
Docker è una piattaforma aperta per lo sviluppo, la distribuzione e l'esecuzione di applicazioni. Con Docker puoi separare le tue applicazioni dalla tua infrastruttura e trattare la tua infrastruttura come un'applicazione gestita. Docker ti aiuta a distribuire, testare e fare il deployment del codice più velocemente, nonché a ridurre il ciclo tra scrittura ed esecuzione del codice.
A questo scopo, combina le funzionalità di containerizzazione dei kernel con workflow e strumenti che ti aiutano a gestire le tue applicazioni e a farne il deployment.
I container Docker possono essere utilizzati direttamente in Kubernetes, il che consente di eseguirli facilmente in Kubernetes Engine. Dopo aver appreso gli elementi essenziali di Docker, avrai le competenze per iniziare a sviluppare applicazioni Kubernetes e containerizzate.
Obiettivi didattici
In questo lab imparerai a:
- Crea un Dockerfile per un'applicazione di esempio
- Crea un'immagine
- Esegui l'immagine come container in locale
- Modificare il comportamento del contenitore
- Esegui il push dell'immagine ad Artifact Registry
Prerequisiti
Si tratta di un lab di livello base. È adatto a chi ha poca o nessuna esperienza con Docker e i container. Suggeriamo, ma non è obbligatoria, esperienza con la riga di comando e Cloud Shell.
Configurazione dell'ambiente autonomo
- Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.
- Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google e puoi aggiornarla in qualsiasi momento.
- L'ID progetto deve essere univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). Cloud Console genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, devi fare riferimento all'ID progetto (che in genere è identificato come
PROJECT_ID), quindi, se non ti piace, generane un altro casuale oppure puoi provare a crearne uno tuo e vedere se è disponibile. Viene "congelato" dopo la creazione del progetto. - Esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. L'esecuzione di questo codelab non dovrebbe costare molto, se non nulla. Per arrestare le risorse in modo da non incorrere in costi di fatturazione al termine di questo tutorial, segui le istruzioni di "pulizia" riportate alla fine del codelab. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.
2. Prova l'applicazione
Per facilitare questo lab, è stata fornita un'applicazione di esempio. In questa sezione recupererai il codice sorgente e creerai l'applicazione nella sua forma nativa prima di passare al processo di containerizzazione.
Codice sorgente
Il codice sorgente di questo lab è disponibile nel repository GoogleCloudPlatform/container-developer-workshop insieme alla documentazione dell'applicazione di esempio.
Configura Git
git config --global user.name ${USER}
git config --global user.email ${USER}@qwiklabs.net
Clona il repository di codice sorgente dell'applicazione di esempio
gcloud source repos clone sample-app ${HOME}/sample-app &&
cd ${HOME}/sample-app &&
git checkout main
Output
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'
Crea l'applicazione di esempio
cd ${HOME}/sample-app
./mvnw compile
Output
[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] ------------------------------------------------------------------------
Esegui l'applicazione di esempio
cd ${HOME}/sample-app
./mvnw exec:java
Output
[INFO] Scanning for projects... ... Listening at http://localhost:8080
Visualizzare l'anteprima dell'applicazione in esecuzione
- Fai clic sul pulsante Anteprima web di Cloud Shell.
- Fai clic su Anteprima sulla porta 8080.
Al termine
- Premi Ctrl + C in Cloud Shell per arrestare l'applicazione in esecuzione.
3. Dockerfile
Containerizzare l'applicazione con un Dockerfile
Un metodo per inserire un'applicazione in un container è l'utilizzo di un Dockerfile. Il Dockerfile è simile a uno script che fornisce istruzioni al daemon su come assemblare l'immagine container. Per saperne di più, consulta la documentazione di riferimento di Dockerfile.
Crea un Dockerfile vuoto nel repository dell'applicazione di esempio.
touch ${HOME}/sample-app/Dockerfile
Apri il Dockerfile nell'editor che preferisci.
vi ${HOME}/sample-app/Dockerfile
Scegliere un'immagine iniziale
L'utilizzo del metodo Dockerfile per creare un container richiede una conoscenza diretta dell'applicazione per assemblare il container. Il primo passaggio per creare un Dockerfile è selezionare un'immagine che verrà utilizzata come base.Questa immagine deve essere un'immagine padre o di base gestita e pubblicata da una fonte attendibile, in genere la tua azienda.
L'istruzione FROM inizializza una nuova fase di compilazione e imposta l'immagine di base per i comandi sequenziali successivi. Pertanto, l'istruzione FROM è in genere la prima istruzione in un Dockerfile e può essere preceduta solo da un'istruzione ARG facoltativa per supportare le variabili.
Sintassi: FROM <image>[:<tag> | @<digest>] [AS <name>]
Il formato di un'immagine è <image>:<tag> o <image>@<digest>. Se non viene specificato un tag o un digest, il valore predefinito è il tag :latest. Il formato di <image> varia in base al registro utilizzato per archiviare l'immagine. Per Artifact Registry, il formato <image> è <region>-docker.pkg.dev/<project ID>/<repository name>/<image name>:<image tag>.
Per questo lab utilizziamo l'immagine pubblica openjdk:11.0-jdk. Aggiungi la seguente riga al Dockerfile
FROM openjdk:11.0-jdk
Imposta la directory di lavoro
L'istruzione WORKDIR imposta la directory di lavoro per le istruzioni sequenziali che seguono nel Dockerfile. Per saperne di più, consulta la sezione WORKDIR della documentazione di riferimento di Dockerfile.
Sintassi: WORKDIR <path>
Per questo lab utilizziamo la directory /app come WORKDIR, aggiungi la seguente riga alla fine del Dockerfile
WORKDIR /app
Copia i file dell'applicazione
L'istruzione COPY copia directory o file dalla posizione <source> al percorso <destination> del file system dell'immagine. È possibile specificare più risorse <source> e sono tutte relative al contesto di build. Il contesto della build verrà discusso più nel dettaglio nella sezione Build. Per saperne di più, consulta la sezione COPY della documentazione di riferimento di Dockerfile.
Sintassi: COPY <source>... <destination>
Per questo lab copieremo tutti i file nel repository nel file system dell'immagine e aggiungeremo la seguente riga alla fine del Dockerfile
COPY . /app
Compilare l'applicazione
L'istruzione RUN esegue i comandi in un nuovo livello dell'immagine sopra l'immagine corrente ed esegue il commit dei risultati. L'immagine di cui è stato eseguito il commit risultante verrà utilizzata per i passaggi sequenziali nel Dockerfile. Per saperne di più, consulta la sezione RUN della documentazione di riferimento di Dockerfile.
Sintassi: RUN <command>
Per questo lab utilizzeremo Maven per compilare l'applicazione in un file JAR. Aggiungi la seguente riga alla fine del Dockerfile
RUN ./mvnw compile assembly:single
Avviare la richiesta
L'istruzione CMD fornisce il comando predefinito per un container in esecuzione. Può esserci una sola istruzione CMD in un Dockerfile. Se ne viene specificata più di una, avrà effetto solo l'ultima. Sono disponibili funzionalità più avanzate utilizzando sia le istruzioni CMD che ENTRYPOINT, ma non sono trattate in questo lab. Per saperne di più, consulta la sezione CMD` della documentazione di riferimento di Dockerfile.
Sintassi: CMD ["executable","param1","param2"]
Per questo lab eseguiamo il file JAR che abbiamo compilato, aggiungendo la seguente riga alla fine del Dockerfile
CMD ["java","-jar","/app/target/sample-app-1.0.0-jar-with-dependencies.jar"]
Dockerfile finale
Il Dockerfile finale sarà
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"]
Esegui il commit del Dockerfile localmente
cd ${HOME}/sample-app
git add Dockerfile
git commit -m "Added Dockerfile"
4. Build
Ora creeremo l'immagine dal Dockerfile utilizzando il comando docker build. Questo comando indica al daemon Docker di creare l'immagine utilizzando le istruzioni del nostro Dockerfile. Per saperne di più, consulta la documentazione di riferimento per la creazione di Docker.
Crea l'immagine
cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker build --tag sample-app:${IMAGE_TAG} .
Output
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. Esegui
Una volta creata correttamente l'immagine container, possiamo eseguire l'applicazione e assicurarci che si comporti come previsto utilizzando il comando docker run. Questo comando avvierà il nostro contenitore in primo piano del prompt dei comandi per il test o il debug. Per saperne di più, consulta la documentazione di riferimento di docker run.
Esegui un container utilizzando l'immagine
cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
--rm \
-p 8080:8080 \
sample-app:${IMAGE_TAG}
Output
Listening at http://localhost:8080
Visualizzare l'anteprima dell'applicazione in esecuzione in un container
- Fai clic sul pulsante Anteprima web di Cloud Shell.
- Fai clic su Anteprima sulla porta 8080.
- Premi Ctrl + C in Cloud Shell per arrestare i container.
Modifica del comportamento del contenitore
L'esecuzione di Docker Run utilizza la configurazione predefinita nel Dockerfile. Per modificare questo comportamento, è possibile aggiungere istruzioni e parametri aggiuntivi.
Abilita il logging 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
Visualizza l'anteprima dell'applicazione in esecuzione in un container
- Fai clic sul pulsante Anteprima web di Cloud Shell.
- Fai clic su Anteprima sulla porta 8080.
- Passa alla scheda Cloud Shell e verifica che la registrazione aggiuntiva
- Premi Ctrl + C in Cloud Shell per arrestare il container.
Cambia porta
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}
Visualizzare l'anteprima dell'applicazione in esecuzione in un container
- Fai clic sul pulsante Anteprima web di Cloud Shell.
- Fai clic su Cambia porta.
- Inserisci 8081
- Fai clic su Cambia e visualizza anteprima.
- Premi Ctrl + C in Cloud Shell per arrestare il container.
6. Push
Una volta verificato che l'immagine container funzioni correttamente e che vogliamo renderla disponibile per l'esecuzione in altri ambienti e/o da parte di altri utenti, dobbiamo eseguire il push dell'immagine in un repository condiviso. Questa operazione dovrebbe avvenire nell'ambito di una pipeline di build automatica, ma nel nostro ambiente di test abbiamo già configurato un repository e possiamo eseguire il push manualmente della nostra immagine.
Esegui il push del commit Dockerfile nel repository sample-app
cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
git push
Tagga l'immagine per Artifact Registry
docker tag sample-app:${IMAGE_TAG} \
us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/apps/sample-app:${IMAGE_TAG}
Configura le credenziali per Artifact Registry
gcloud auth configure-docker us-central1-docker.pkg.dev
Quando richiesto Do you want to continue (Y/n)? rispondi y e premi Enter
Esegui il push dell'immagine ad Artifact Registry
docker push us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/apps/sample-app:${IMAGE_TAG}
Output
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. Complimenti!
Congratulazioni, hai completato il codelab.
Argomenti trattati
- Creazione di un Dockerfile per un'applicazione di esempio
- Creata un'immagine
- Eseguito l'immagine come container localmente
- Modifica del comportamento dei container
- Esegui il push dell'immagine in Artifact Registry