Percorso di apprendimento: trasforma un monolito in un'app GKE - Containerizza l'app modulare

Questo è il quarto tutorial di un percorso di apprendimento che ti insegna come modularizzare e containerizzare un'app monolitica.

Il percorso di apprendimento è costituito dai seguenti tutorial:

  1. Panoramica
  2. Informazioni sul monolite
  3. Modularizza il monolite
  4. Preparare l'app modulare per la containerizzazione
  5. Containerizza l'app modulare (questo tutorial)
  6. Esegui il deployment dell'app in un cluster GKE

Nel tutorial precedente, Prepara l'app modulare per la containerizzazione, hai visto quali modifiche dovevano essere apportate alla versione modulare dell'app Cymbal Books per prepararla alla containerizzazione. In questo tutorial, containerizzi l'app.

Costi

Puoi completare questo tutorial senza incorrere in alcun addebito. Tuttavia, seguendo i passaggi del tutorial successivo di questa serie, verranno addebitati costi sul tuo accountGoogle Cloud . I costi iniziano quando abiliti GKE ed esegui il deployment dell'app Cymbal Books in un cluster GKE. Questi costi includono gli addebiti per cluster per GKE, come descritto nella pagina dei prezzi, e gli addebiti per l'esecuzione delle VM di Compute Engine.

Per evitare addebiti non necessari, assicurati di disabilitare GKE o eliminare il progetto al termine di questo tutorial.

Prima di iniziare

Prima di iniziare questo tutorial, assicurati di aver completato i tutorial precedenti della serie. Per una panoramica dell'intera serie e link a tutorial specifici, consulta Learning Path: Transform a monolith into a GKE app - Overview.

Configura l'ambiente

In questa sezione configurerai un ambiente in cui inserire in un container l'app modulare. Nello specifico, eseguirai i seguenti passaggi:

  1. Seleziona o crea un Google Cloud progetto
  2. Abilita le API necessarie
  3. Collega Cloud Shell al tuo progetto Google Cloud
  4. Impostare le variabili di ambiente predefinite
  5. Crea un repository in Artifact Registry
  6. Configura Docker per Artifact Registry
  7. Ottenere il codice del tutorial

Seleziona o crea un Google Cloud progetto

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  2. Make sure that billing is enabled for your Google Cloud project.

Abilita le API necessarie

Per lavorare con le immagini container e Kubernetes nel tuo progetto Google Cloud , devi abilitare le seguenti API:

  • API Artifact Registry: questa API abilita Artifact Registry, un servizio per l'archiviazione e la gestione delle immagini container.
  • API Kubernetes Engine: questa API fornisce l'accesso a GKE.

Per abilitare queste API, visita la pagina Abilita le API nella console Google Cloud .

Connetti Cloud Shell al tuo progetto Google Cloud

Ora che hai configurato il progetto Google Cloud , devi avviare un'istanza di Cloud Shell e connetterla al progetto Google Cloud. Cloud Shell è uno strumento a riga di comando che ti consente di creare e gestire le risorse di un progetto direttamente dal browser. Cloud Shell include due strumenti importanti preinstallati: la gcloud CLI e la kubectl CLI. In questo tutorial, utilizzerai gcloud CLI per interagire con Google Cloud e nel tutorial successivo utilizzerai l'interfaccia a riga di comando kubectl per gestire l'app Cymbal Books in esecuzione su GKE.

Per connettere un'istanza Cloud Shell al tuo Google Cloud progetto, segui questi passaggi:

  1. Vai alla Google Cloud console:

    Google Cloud console

  2. Nella console, fai clic sul pulsante Attiva Cloud Shell: Attiva Cloud Shell

    Una sessione di Cloud Shell si apre in un frame nella parte inferiore della console.

  3. Imposta il progetto predefinito in Google Cloud CLI utilizzando il seguente comando:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con l'ID progetto del progetto che hai creato o selezionato nella sezione precedente, Seleziona o crea Google Cloud progetto. Un ID progetto è una stringa univoca che distingue il tuo progetto da tutti gli altri progetti in Google Cloud. Per individuare l'ID progetto, vai al selettore dei progetti. In questa pagina puoi visualizzare gli ID progetto di ciascuno dei tuoi Google Cloud progetti.

Imposta le variabili di ambiente predefinite

Per semplificare i comandi che esegui durante questo tutorial, ora imposta alcune variabili di ambiente in Cloud Shell. Queste variabili memorizzano valori come l'ID progetto, la regione del repository e il tag immagine. Dopo aver definito queste variabili, puoi riutilizzarle in più comandi facendo riferimento al nome della variabile (ad esempio, $REPOSITORY_NAME) anziché digitare o sostituire i valori ogni volta. Questo approccio rende il tutorial più facile da seguire e riduce il rischio di errori.

Per configurare l'ambiente con Cloud Shell, segui questi passaggi:

export PROJECT_ID=$(gcloud config get project)
export REPOSITORY_REGION=REPOSITORY_REGION
export REPOSITORY_NAME=REPOSITORY_NAME
export REPOSITORY_DESCRIPTION="REPOSITORY_DESCRIPTION"
export TAG=TAG

Sostituisci quanto segue:

  • REPOSITORY_REGION: la regione in cui vuoi che venga ospitato il tuo repository Artifact Registry. Ad esempio, us-central1 (Iowa), us-west1 (Oregon) o europe-west1 (Belgio). Per un elenco completo delle regioni, consulta Regioni e zone.
  • REPOSITORY_NAME: il nome del repository. Ad esempio, book-review-service-repo.
  • REPOSITORY_DESCRIPTION: una breve descrizione dello scopo del repository. Ad esempio, "Repository for storing Docker images for the book review service".
  • TAG: il tag che vuoi applicare a un'immagine. Un tag è un'etichetta che puoi collegare a una versione specifica di un'immagine container. Puoi utilizzare convenzioni di denominazione dei tag come queste per indicare chiaramente le diverse versioni di un'immagine:
    • v1
    • v1.2.3
    • Un tag descrittivo, ad esempio feature-x-dev
    • Un tag che indica l'ambiente, ad esempio test

Crea un repository in Artifact Registry

A questo punto, crea un repository in Artifact Registry. Un repository è una posizione di archiviazione in cui conservare le immagini container. Quando crei un'immagine container, devi archiviarla da qualche parte in modo che possa essere sottoposta a deployment in un cluster Kubernetes. Artifact Registry ti consente di creare e gestire questi repository all'interno del tuo progetto Google Cloud .

Per creare un repository in Artifact Registry, esegui questo comando:

gcloud artifacts repositories create ${REPOSITORY_NAME} \
    --repository-format=docker \
    --location=${REPOSITORY_REGION} \
    --description="${REPOSITORY_DESCRIPTION}"

L'output riuscito del comando è simile al seguente:

Waiting for operation [...] to complete...done.
Created repository [book-review-service-repo].

Configura Docker per Artifact Registry

Successivamente, configura Docker in modo che possa comunicare in modo sicuro con Artifact Registry diGoogle Cloud. Docker è uno strumento che puoi utilizzare per pacchettizzare ed eseguire software in modo coerente in ambienti diversi. Scopri di più su come funziona Docker nella sezione successiva. Per ora, devi configurarlo in modo che possa connettersi ad Artifact Registry.

Se non configuri Docker in questo modo, non puoi eseguire il push delle immagini container in Artifact Registry (un'attività che svolgerai più avanti in questo tutorial). Inoltre, non puoi estrarre le immagini container da Artifact Registry ed eseguirne il deployment in un cluster GKE (un'attività che svolgerai nel tutorial successivo).

Per configurare Docker per l'autenticazione con Artifact Registry, esegui questo comando:

gcloud auth configure-docker ${REPOSITORY_REGION}-docker.pkg.dev

Ottenere il codice del tutorial

Ora che l'ambiente Cloud Shell è configurato, devi scaricare il codice del tutorial in Cloud Shell. Anche se in precedenza hai clonato il repository sulla tua macchina locale, devi clonarlo di nuovo qui sulla tua istanza di Cloud Shell.

Sebbene sia possibile completare questo tutorial sulla tua macchina locale, dovresti installare e configurare manualmente diversi strumenti come Docker, kubectl e gcloud CLI. L'utilizzo di Cloud Shell è più semplice perché è preconfigurato con tutti questi strumenti.

Nell'istanza di Cloud Shell, esegui questo comando per clonare il repository GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

Nozioni di base sulla containerizzazione: immagini container, container e Dockerfile

Ora che hai configurato l'ambiente e scaricato il codice containerizzato, puoi containerizzare l'app. La containerizzazione dell'app consiste nell'utilizzare un Dockerfile per pacchettizzare ogni modulo di Cymbal Books (home page, dettagli del libro, immagini e recensioni del libro) in un'immagine container. Quando l'applicazione viene deployata nel cluster GKE, Kubernetes utilizza queste immagini container per creare container in esecuzione nel cluster.

Le sezioni seguenti spiegano questi concetti in dettaglio.

Che cos'è la containerizzazione?

La containerizzazione pacchettizza un modulo e tutte le sue dipendenze, come librerie e file di configurazione, in un'unità chiamata immagine container. Gli sviluppatori utilizzano questa immagine container per creare ed eseguire container in qualsiasi ambiente, dal laptop di uno sviluppatore a un server di test o a un cluster Kubernetes di produzione.

Che cosa sono le immagini container?

Un'immagine container contiene tutti i file necessari per eseguire un'applicazione. Questi file includono il codice dell'applicazione, le librerie di sistema, l'ambiente di runtime (ad esempio, l'interprete Python), i dati statici e qualsiasi altra dipendenza.

In questo tutorial, creerai un'immagine container per ogni modulo dell'app di recensioni di libri.

Che cos'è un container?

Un container è un ambiente isolato in cui viene eseguito il codice di un'immagine container. Puoi creare container in due modi: utilizzando il comando docker run per i test durante lo sviluppo o eseguendo il deployment delle immagini container in un cluster Kubernetes.

Nella versione containerizzata dell'app Cymbal Books, ogni modulo dell'app modulare viene eseguito nel proprio container:

  • Il contenitore della home page esegue il modulo della home page e gestisce le richieste a /.
  • Il container dei dettagli del libro esegue il modulo dei dettagli del libro e gestisce i dati per endpoint come /book/1 o /book/3.
  • Il contenitore delle recensioni di libri esegue il modulo delle recensioni di libri e gestisce le richieste agli endpoint come /book/2/reviews.
  • Il container delle immagini esegue il modulo delle immagini e pubblica le immagini di copertina dei libri per endpoint come /images/fungi_frontier.jpg.

Uno dei principali vantaggi dei container è che Kubernetes può crearne automaticamente altri quando necessario. Ad esempio, se numerosi utenti leggono recensioni di libri, Kubernetes può avviare altri container di recensioni di libri per gestire il carico.

Per implementare lo scaling in un'app modulare che non utilizza container, devi scrivere codice personalizzato per avviare nuove istanze di un modulo e distribuire il traffico tra queste. Con Kubernetes, questa funzionalità di scalabilità è integrata: non devi scrivere codice di scalabilità personalizzato.

Che cosa sono i Dockerfile?

Un Dockerfile è uno script che definisce come creare un pacchetto di un modulo in un'immagine container. In questo tutorial non devi creare Dockerfile, perché sono già forniti nel repository GitHub che hai clonato in precedenza. La directory di ogni modulo nella tua copia locale di kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/ contiene il proprio Dockerfile.

Ad esempio, puoi trovare il Dockerfile del modulo home_app nella tua istanza di Cloud Shell all'indirizzo kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/home_app/Dockerfile. Questo Dockerfile ha il seguente aspetto:

# Dockerfile for home_app
FROM python:3.9-slim #line 1
WORKDIR /app #line 2
COPY requirements.txt . #line 3
RUN pip install --no-cache-dir -r requirements.txt #line 4
COPY home_app.py . #line 5
COPY templates/ ./templates/ #line 6
COPY static/ ./static/ #line 7
CMD ["python", "home_app.py"] #line 8

Questo Dockerfile esegue i seguenti passaggi per creare l'immagine container per il modulo home_app:

  • Riga 1: FROM python:3.9-slim scarica un interprete Python 3.9 e i relativi file richiesti nell'immagine del container. Questi file consentono l'esecuzione del modulo.
  • Riga 2: WORKDIR /app crea una directory denominata /app all'interno del container e la imposta come directory di lavoro corrente. Tutti i comandi eseguiti all'interno del container verranno eseguiti da questa directory.
  • Righe 3 e 4: COPY requirements.txt . copia il file requirements.txt dalla tua macchina locale nella directory /app dell'immagine container. Il file requirements.txt elenca tutte le librerie Python di cui home_app.py ha bisogno. La riga RUN pip install installa queste librerie nell'immagine container.
  • Righe da 5 a 7: i comandi COPY che compaiono in queste righe copiano il codice del modulo (home_app.py) e i relativi file di supporto (modelli e asset statici) nella directory /app all'interno dell'immagine container.
  • Riga 8: CMD specifica il comando predefinito che Docker esegue all'avvio del container. In questo Dockerfile, CMD ["python", "home_app.py"] indica a Docker di utilizzare l'interprete Python per eseguire automaticamente il modulo home_app.py all'avvio del container.

In che modo la containerizzazione può imporre un isolamento più rigoroso dei dati

Le righe da 5 a 7 del Dockerfile, descritte nella sezione precedente, mostrano come la containerizzazione possa imporre un isolamento dei dati più rigoroso rispetto alla versione modulare dell'app. In un tutorial precedente, nella sezione Concedi a ogni modulo l'accesso solo ai dati di cui ha bisogno, hai appreso che la versione modulare dell'app organizza i dati in directory separate, ma i moduli condividono comunque lo stesso file system e potrebbero potenzialmente accedere ai dati degli altri.

Qui, nella versione containerizzata dell'app, il container di ogni modulo include solo i file necessari. Ad esempio, se il modulo home_app non ha bisogno di accedere ai dati delle recensioni di libri, questi dati semplicemente non esistono all'interno del container home_app. Per impostazione predefinita, un container non può accedere ai file di un altro container, a meno che non sia configurato esplicitamente per farlo. In questo modo, ogni modulo è completamente isolato e si impedisce l'accesso accidentale o non autorizzato ai dati.

Nella sezione successiva vedrai come il comando docker build prende un Dockerfile come input e segue le istruzioni nel Dockerfile per creare un'immagine container.

Crea immagini container utilizzando Docker

In questa sezione, crei immagini container Docker per ciascuno dei moduli di recensione di libri ed esegui il push nel repository Artifact Registry. Utilizzerai queste immagini container in un tutorial successivo per eseguire il deployment ed eseguire l'app di esempio Cymbal Books in Kubernetes.

  1. Vai alla directory radice dell'applicazione containerizzata:

    cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/

  2. Crea le immagini container utilizzando il comando docker build:

    docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/home-app:${TAG} ./home_app
docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app:${TAG} ./book_details_app
docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app:${TAG} ./book_reviews_app
docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app:${TAG} ./images_app

  3. Visualizza le immagini container create all'interno dell'istanza Cloud Shell:

    docker images

    Controlla che nell'elenco siano presenti le seguenti immagini:

    • home-app
    • book-details-app
    • book-reviews-app
    • images-app

    Se sono elencate tutte e quattro le immagini, hai creato correttamente le immagini container.

Testare i container in Cloud Shell

Per verificare che le immagini container siano create correttamente, puoi eseguirle come container e testare i relativi endpoint in Cloud Shell.

I container book_details_app, book_reviews_app e images_app possono essere testati singolarmente perché non devono comunicare tra loro. Tuttavia, testare il container home_app utilizzando Docker è difficile perché home_appè configurato per trovare gli altri container che utilizzano nomi di servizio come http://book-details-service:8081.

Sebbene sia possibile testare il container home_app trovando l'indirizzo IP di ogni container e configurando home_app per utilizzarli anziché i nomi dei servizi, questo approccio richiede molto impegno. È invece consigliabile posticipare il test del container home_app dopo il deployment dell'applicazione in un cluster Kubernetes. Dopo che l'app è sul cluster, puoi determinare se il modulo Home funziona correttamente.

Per testare i contenitori:

  1. Avvia i container book_details_app, book_reviews_app e images_app:

    docker run -d -p 8081:8080 ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app:${TAG}
docker run -d -p 8082:8080 ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app:${TAG}
docker run -d -p 8083:8080 ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app:${TAG}

  2. Controlla che i container siano in esecuzione elencando tutti i container attivi:

    docker ps

    L'output di questo comando dovrebbe mostrare tre container in esecuzione, con lo stato Up:

    CONTAINER ID   IMAGE                PORTS                        STATUS
a1b2c3d4e5f6   REGION/.../details   0.0.0.0:8081->8080/tcp       Up
g7h8i9j0k1l2   REGION/.../reviews   0.0.0.0:8082->8080/tcp       Up
m3n4o5p6q7r8   REGION/.../images    0.0.0.0:8083->8080/tcp       Up

  3. Per testare gli endpoint del container book_details_app, utilizza i seguenti comandi curl:

    curl http://localhost:8081/books
curl http://localhost:8081/book/1
curl http://localhost:8081/book/2
curl http://localhost:8081/book/3

    Ognuno di questi comandi restituisce i dati in formato JSON. Ad esempio, l'output del comando curl http://localhost:8081/book/1 ha questo aspetto:

    {"author":"Aria Clockwork","description":"In a world where time is a tangible substance, a young clockmaker discovers she can manipulate the fabric of time itself, leading to unforeseen consequences in her steampunk-inspired city.","id":1,"image_url":"zephyrs_timepiece.jpg","title":"Zephyr's Timepiece","year":2023}

  4. Recupera le recensioni dei libri dal contenitore book_reviews_app utilizzando questo comando curl:

    curl http://localhost:8082/book/1/reviews

    Questo comando restituisce un elenco di 20 recensioni del libro 1 in formato JSON. Ecco un esempio di recensione dell'elenco:

    {
"content": "The concept of time as a tangible substance is brilliantly explored in 'Zephyr's Timepiece'.",
"rating": 5
}

  5. Testa il container images_app:

    1. Fai clic sul pulsante **Web Preview**. Pulsante Anteprima web

    2. Seleziona Cambia porta e inserisci 8083. Si apre una finestra del browser con un URL simile a questo:

      https://8083-your-instance-id.cs-your-region.cloudshell.dev/?authuser=0

    3. Rimuovi ?authuser=0 alla fine dell'URL e aggiungi il percorso di un file immagine, ad esempio /images/fungi_frontier.jpg. Di seguito è riportato un esempio:

      https://8083-your-instance-id.cs-your-region.cloudshell.dev/images/fungi_frontier.jpg

      Dovresti vedere l'immagine di copertina del libro Fungi Frontier visualizzata nel browser.

  6. Dopo il test, arresta i container per rilasciare le risorse:

    1. Elenca i container in esecuzione e trova i relativi ID container:

      docker ps

    2. Arresta ogni container:

      docker stop CONTAINER_ID

      Sostituisci CONTAINER_ID con l'ID del contenitore che vuoi arrestare.

Esegui il push delle immagini container in Artifact Registry

Prima di poter eseguire il deployment della tua app in un cluster Kubernetes, le immagini container devono essere archiviate in una posizione a cui il cluster può accedere. In questo passaggio, esegui il push delle immagini nel repository Artifact Registry creato in precedenza. Nel tutorial successivo, esegui il deployment di queste immagini dal repository Artifact Registry a un cluster GKE:

  1. Per eseguire il push delle immagini container in Artifact Registry, esegui questi comandi:

    docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/home-app:${TAG}
docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app:${TAG}
docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app:${TAG}
docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app:${TAG}

  2. Dopo aver eseguito il push delle immagini, verifica che siano state caricate correttamente elencandole:

    gcloud artifacts docker images list ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}

    Dovresti vedere un output simile al seguente:

    Listing items under project ${PROJECT_ID}, location ${REPOSITORY_REGION}, repository ${REPOSITORY_NAME}.

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app
DIGEST: sha256:f7b78f44d70f2eedf7f7d4dc72c36070e7c0dd05daa5f473e1ebcfd1d44b95b1
CREATE_TIME: 2024-11-14T00:38:53
UPDATE_TIME: 2024-11-14T00:38:53
SIZE: 52260143

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app
DIGEST: sha256:875ac8d94ef54db2ff637e49ad2d1c50291087623718b854a34ad657748fac86
CREATE_TIME: 2024-11-14T00:39:04
UPDATE_TIME: 2024-11-14T00:39:04
SIZE: 52262041

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/home-app
DIGEST: sha256:70ddc54ffd683e2525d87ee0451804d273868c7143d0c2a75ce423502c10638a
CREATE_TIME: 2024-11-14T00:33:56
UPDATE_TIME: 2024-11-14T00:33:56
SIZE: 52262412

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app
DIGEST: sha256:790f0d8c2f83b09dc3b431c4c04d7dc68254fecc76c48f00a83babc2a5dc0484
CREATE_TIME: 2024-11-14T00:39:15
UPDATE_TIME: 2024-11-14T00:39:15
SIZE: 53020815

    L'output include i seguenti dettagli per ogni immagine:

    • IMAGE: il percorso del repository e il nome dell'immagine.
    • DIGEST: un identificatore univoco per l'immagine.
    • CREATE_TIME o UPDATE_TIME: data di creazione o ultima modifica dell'immagine.
    • SIZE: le dimensioni dell'immagine in byte.

Aggiorna il manifest di Kubernetes con i percorsi delle immagini container

Come hai appreso nel tutorial precedente, Preparare l'app modulare per la containerizzazione, un manifest Kubernetes è un file YAML che definisce come viene eseguita l'app in un cluster Kubernetes. Include dettagli come:

  • I moduli della tua app (ad esempio,home-app, book-details-app)
  • Percorsi delle immagini container
  • Dettagli di configurazione, come i limiti delle risorse
  • Definizioni di servizio per il routing delle richieste tra i moduli

In questa sezione, aggiorni lo stesso file manifest che hai esaminato nel tutorial precedente. Questo file è kubernetes-manifest.yaml e contiene valori segnaposto per i percorsi delle immagini. Devi sostituire questi segnaposto con i percorsi effettivi delle immagini container di cui hai eseguito il push nel repository Artifact Registry nella sezione precedente.

Per aggiornare il file manifest di Kubernetes kubernetes-manifest.yaml, segui questi passaggi:

  1. In Cloud Shell, vai alla directory containerized/, che contiene il file manifest Kubernetes kubernetes-manifest.yaml:

    cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/

  2. Apri il file kubernetes-manifest.yaml in un editor di testo:

    vim kubernetes-manifest.yaml

  3. Individua i campi image che contengono segnaposto come questo:

    image: REPOSITORY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_NAME/home-app:TAG

    Sostituisci ogni segnaposto con i percorsi effettivi delle immagini container di cui hai eseguito il push in Artifact Registry:

    Ecco come potrebbe apparire un percorso dopo aver effettuato queste sostituzioni:

    image:us-west1-docker.pkg.dev/your-project-id/book-review-service-repo/home-app:v1

  4. Aggiorna i percorsi per tutte le immagini container:

    • home-app
    • book-details-app
    • book-reviews-app
    • images-app

  5. Dopo aver aggiornato i percorsi, salva il file manifest e chiudi l'editor. Ad esempio, se utilizzi vim, premi Esc per attivare la modalità comando, digita wq e premi Invio per salvare e uscire.

Il manifest Kubernetes è ora configurato per eseguire il deployment delle immagini container dal repository Artifact Registry a un cluster Kubernetes.

Riepilogo

In questo tutorial hai preparato l'app modulare Cymbal Books per il deployment in un cluster Kubernetes eseguendo le seguenti attività:

  1. Configura un progetto Google Cloud e Cloud Shell per il tuo ambiente.
  2. Ha esaminato i Dockerfile forniti per ogni modulo dell'app.
  3. Immagini container create per i moduli dell'app utilizzando Docker.
  4. Contenitori testati in Cloud Shell per verificarne la funzionalità.
  5. Eseguito il push delle immagini container in Artifact Registry per l'archiviazione.
  6. È stato aggiornato il manifest Kubernetes in modo da utilizzare i percorsi delle immagini container corretti da Artifact Registry.

Passaggi successivi

Nel tutorial successivo, Esegui il deployment dell'app in un cluster GKE, esegui il deployment dell'applicazione containerizzata in un cluster GKE.