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 ed eseguire il deployment del codice più velocemente e a ridurre il ciclo tra scrittura ed esecuzione del codice.
Per farlo combina le funzionalità di containerizzazione dei kernel con flussi di lavoro e strumenti che ti aiutano a gestire le tue applicazioni e a eseguirne 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:
- Creare un Dockerfile per un'applicazione di esempio
- Creare un'immagine
- Eseguire l'immagine come container in locale
- Modificare il comportamento del container
- Eseguire 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 già 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 l'impostazione). La console Cloud genera automaticamente una stringa univoca; in genere non ti interessa quale sia. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (che in genere viene identificato come
PROJECT_ID), quindi, se non ti piace, generane un altro casuale oppure puoi provare il tuo e verificare se è disponibile. Dopo la creazione del progetto, l'ID progetto è "bloccato". - Esiste un terzo valore, un numero di progetto , utilizzato da alcune API. Scopri di più su tutti e tre i valori nella documentazione.
- Dopodiché, devi abilitare la fatturazione nella console Cloud per utilizzare le risorse/API Cloud. Completare questo codelab non dovrebbe costare molto, se non nulla. Per arrestare le risorse in modo da non incorrere in addebiti oltre questo tutorial, segui le istruzioni di "pulizia" riportate alla fine del codelab. I nuovi utenti di Google Cloud possono usufruire del programma di 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 per 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 Cloud 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
Visualizza 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
Containerizzazione dell'applicazione con un Dockerfile
Un metodo per pacchettizzare un'applicazione in un container è l'utilizzo di un Dockerfile. Il Dockerfile è simile a uno script che indica al daemon 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
Scegli un'immagine iniziale
L'utilizzo del metodo Dockerfile per creare un container richiede la conoscenza diretta dell'applicazione per assemblare il container. Il primo passo per creare un Dockerfile è selezionare un'immagine che verrà utilizzata come base dell'immagine.Questa immagine deve essere un'immagine principale o di base gestita e pubblicata da una fonte attendibile, in genere la tua azienda.
L'istruzione FROM inizializza una nuova fase di creazione 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, viene utilizzato per impostazione predefinita 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 successive 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>, tutte relative al contesto di creazione. Il contesto di creazione verrà trattato più avanti nella sezione Creazione. 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 del repository nel file system dell'immagine. Aggiungi la seguente riga alla fine del Dockerfile
COPY . /app
Compila 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
Avvia l'applicazione
L'istruzione CMD fornisce il comando predefinito per un container in esecuzione. In un Dockerfile può essere presente una sola istruzione CMD. Se ne vengono specificate più di una, avrà effetto solo l'ultima. Sono disponibili funzionalità più avanzate che utilizzano 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. Aggiungi 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 in locale
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 Dockerfile. Per saperne di più, consulta la documentazione di riferimento di docker build.
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
Dopo aver creato correttamente l'immagine container, ora possiamo eseguire l'applicazione e assicurarci che si comporti come previsto utilizzando il comando docker run. Questo comando avvierà il container in primo piano nel prompt dei comandi per test o 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
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
- Premi Ctrl + C in Cloud Shell per arrestare i container
Modifica del comportamento del container
L'esecuzione di Docker Run utilizza la configurazione predefinita nel Dockerfile. È possibile aggiungere istruzioni e parametri aggiuntivi per modificare questo comportamento.
Abilita la registrazione 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 sia stata aggiunta la registrazione
- 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}
Visualizza 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 altri utenti, dobbiamo eseguire il push dell'immagine in un repository condiviso. Questa operazione dovrebbe avvenire nell'ambito di una pipeline di build automatizzata, ma nel nostro ambiente di test abbiamo già configurato un repository e possiamo eseguire manualmente il push dell'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 ti viene chiesto 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!
Complimenti! Hai completato il codelab.
Argomenti trattati
- Hai creato un Dockerfile per un'applicazione di esempio
- Hai creato un'immagine
- Hai eseguito l'immagine come container in locale
- Hai modificato il comportamento del container
- Hai eseguito il push dell'immagine ad Artifact Registry