Esegui il deployment di un'app server web containerizzata

Questo tutorial descrive come caricare un'applicazione containerizzata in un ambiente con air gap di Google Distributed Cloud (GDC) e come eseguirla su un cluster Kubernetes. Un carico di lavoro containerizzato viene eseguito su un cluster Kubernetes all'interno di uno spazio dei nomi del progetto. I cluster sono logicamente separati dai progetti e tra loro per fornire diversi domini di errore e garanzie di isolamento. Tuttavia, devi assicurarti che il cluster sia collegato a un progetto per consentire la gestione dei carichi di lavoro containerizzati all'interno di un progetto.

Questo flusso di lavoro è destinato agli sviluppatori di applicazioni del gruppo di operatori di applicazioni responsabili della creazione di carichi di lavoro delle applicazioni per la propria organizzazione. Per saperne di più, consulta la sezione Pubblico della documentazione di GDC con air gap.

Uno dei maggiori ostacoli al deployment di un'app containerizzata è il trasferimento del file binario dell'app al data center con air gap. Collabora con il team di infrastruttura e gli amministratori per trasferire l'applicazione alla tua workstation o implementare questo tutorial direttamente sul server di integrazione continua e distribuzione continua (CI/CD).

Questo tutorial utilizza un'app server web di esempio disponibile in Artifact Registry. Google Cloud

Obiettivi

  • Crea un registro Harbor gestito.
  • Esegui il push di un'immagine container nel registro Harbor gestito.
  • Crea un cluster Kubernetes.
  • Esegui il deployment dell'app containerizzata di esempio nel cluster.

Costi

Poiché GDC è progettato per essere eseguito in un data center con air gap, i processi e le informazioni di fatturazione sono limitati solo al deployment di GDC e non sono gestiti da altri prodotti Google.

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

Utilizza la dashboard Costo previsto per prevedere i costi futuri degli SKU per le tue fatture.

Per monitorare il consumo di spazio di archiviazione e di calcolo, utilizza le dashboard di utilizzo della fatturazione.

Prima di iniziare

  1. Assicurati di avere un progetto per gestire i deployment containerizzati. Crea un progetto se non ne hai uno.

  2. Imposta lo spazio dei nomi del progetto come variabile di ambiente:

    export NAMESPACE=PROJECT_NAMESPACE

  3. Scarica e installa l'interfaccia a riga di comando gcloud.

  4. Chiedi all'amministratore IAM dell'organizzazione di concederti i seguenti ruoli:

    • Ruolo di amministratore dello spazio dei nomi (namepspace-admin) per lo spazio dei nomi del progetto. Questo ruolo è necessario per eseguire il deployment dei carichi di lavoro containerizzati nel progetto.

    • Ruolo di amministratore dell'istanza Harbor (harbor-instance-admin) per lo spazio dei nomi del progetto. Questo ruolo è necessario per l'accesso in lettura e scrittura a tutte le risorse Harbor. È necessario anche per eliminare le istanze Harbor.

    • Ruolo di visualizzatore dell'istanza Harbor (harbor-instance-viewer) per lo spazio dei nomi del progetto. Questo ruolo è necessario per visualizzare e selezionare un'istanza Harbor.

    • Ruolo Project Creator (harbor-project-creator) per lo spazio dei nomi del progetto. Questo ruolo è necessario per accedere a un progetto Harbor e gestirlo.

    • Ruolo di amministratore del cluster utente (user-cluster-admin). Questo ruolo è necessario per creare un cluster Kubernetes e non è vincolato a uno spazio dei nomi.

  5. Accedi al server API di gestione di zona e genera il relativo file kubeconfig con un' identità utente. Imposta il percorso kubeconfig come variabile di ambiente:

    export MANAGEMENT_API_SERVER=MANAGEMENT_API_SERVER_KUBECONFIG_PATH

Crea un registro Harbor gestito

GDC con air gap fornisce Harbor as a Service, un servizio completamente gestito che ti consente di archiviare e gestire le immagini container utilizzando Harbor.

Per utilizzare Harbor as a Service, devi prima creare un'istanza del registro Harbor e un progetto Harbor.

Crea un'istanza del registro Harbor

Per creare un'istanza del registro container Harbor:

Console

  1. Nel menu di navigazione, seleziona Harbor Container Registry dalla sezione CI/CD.

  2. Seleziona la zona in cui creare l'istanza Harbor. Un'istanza Harbor è una risorsa di zona e deve essere creata manualmente in ogni zona per garantire un'alta affidabilità.

  3. Fai clic su Crea istanza.

  4. Inserisci il nome dell'istanza e accetta i Termini di servizio gestiti di Harbor.

  5. Fai clic su Crea istanza.

  6. Verifica che la nuova istanza Harbor sia presente nella sezione Istanza Harbor.

  7. Fai clic sul link esterno Vai all'istanza Harbor e prendi nota dell'URL dell'istanza. Ad esempio, il formato dell'URL dell'istanza è simile a harbor-1.org-1.zone1.google.gdc.test. L'URL dell'istanza non deve includere il prefisso https://.

  8. Imposta l'URL dell'istanza come variabile da utilizzare più avanti nel tutorial:

    export INSTANCE_URL=INSTANCE_URL

    Sostituisci INSTANCE_URL con l'URL dell'istanza del registro Harbor.

    Ad esempio:

    export INSTANCE_URL=harbor-1.org-1.zone1.google.gdc.test

gdcloud

  1. Crea la nuova istanza del registro container Harbor:

    gdcloud harbor instances create INSTANCE_NAME \
    --project=PROJECT \

    Sostituisci quanto segue:

    • INSTANCE_NAME: il nome dell'istanza Harbor.
    • PROJECT: il nome del progetto GDC.

  2. Elenca l'URL dell'istanza:

    gdcloud harbor instances describe INSTANCE_NAME \
    --project=PROJECT

    L'output è simile al seguente:

    # Several lines of code are omitted here.
status:
  url: https://harbor-1.org-1.zone1.google.gdc.test

  3. Imposta l'URL dell'istanza come variabile da utilizzare più avanti nel tutorial:

    export INSTANCE_URL=INSTANCE_URL

    Sostituisci INSTANCE_URL con l'URL dell'istanza del registro Harbor. Assicurati che l'URL dell'istanza non includa il prefisso https://.

    Ad esempio:

    export INSTANCE_URL=harbor-1.org-1.zone1.google.gdc.test

Crea un progetto Harbor nel registro

Devi creare un progetto Harbor all'interno dell'istanza del registro Harbor per gestire le immagini container:

Console

  1. Fai clic su Crea un progetto Harbor nella pagina Container Registry Harbor.

  2. Inserisci il nome del progetto.

  3. Fai clic su Crea.

  4. Imposta il nome del progetto Harbor come variabile da utilizzare più avanti nel tutorial:

    export HARBOR_PROJECT=HARBOR_PROJECT

gdcloud

  1. Crea il nuovo progetto Harbor:

    gdcloud harbor harbor-projects create HARBOR_PROJECT \
    --project=PROJECT \
    --instance=INSTANCE_NAME

    Sostituisci quanto segue:

    • HARBOR_PROJECT: il nome del progetto Harbor da creare.
    • PROJECT: il nome del progetto GDC.
    • INSTANCE_NAME: il nome dell'istanza Harbor.

  2. Imposta il nome del progetto Harbor come variabile da utilizzare più avanti nel tutorial:

    export HARBOR_PROJECT=HARBOR_PROJECT

Configura Docker

Per utilizzare Docker nel registro Harbor:

  1. Configura Docker in modo che consideri Harbor as a Service come attendibile. Per saperne di più, consulta Configurare Docker in modo che consideri attendibile la CA principale di Harbor.

  2. Configura l'autenticazione Docker in Harbor. Per saperne di più, consulta Configurare l'autenticazione Docker per le istanze del registro Harbor.

Crea un secret di pull delle immagini Kubernetes

Poiché utilizzi un progetto Harbor privato, devi creare un secret di pull delle immagini Kubernetes.

  1. Aggiungi un account robot del progetto Harbor da utilizzare come account di servizio.

    1. Dalla console Harbor, seleziona il progetto Harbor.

    2. Fai clic su Account robot.

    3. Seleziona Nuovo account robot.

    4. Assegna un nome al nuovo account robot e definisci eventuali impostazioni aggiuntive.

    5. Fai clic su Aggiungi.

    6. Il nome e il secret dell'account robot vengono visualizzati nella schermata di successo. Mantieni aperta questa schermata per riferimento nel passaggio successivo.

    Per saperne di più, consulta la documentazione di Harbor: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#add-a-robot-account.

  2. In una nuova finestra del terminale, accedi a Docker con l'account robot del progetto Harbor e il token secret:

    docker login ${INSTANCE_URL}

    Quando richiesto, inserisci il nome del progetto robot per Nome utente e il token secret per la Password forniti nel passaggio precedente dalla schermata di successo della console Harbor.

  3. Imposta un nome arbitrario per il secret di pull delle immagini:

    export SECRET=SECRET

  4. Crea il secret necessario per il pull delle immagini:

    kubectl create secret docker-registry ${SECRET}  \
    --from-file=.dockerconfigjson=DOCKER_CONFIG \
    -n ${NAMESPACE}

    Sostituisci DOCKER_CONFIG con il percorso del file .docker/config.json.

  5. Verifica che il secret esista nello spazio dei nomi del progetto GDC:

    kubectl get secrets -n ${NAMESPACE}

    L'output è simile al seguente:

    NAME          TYPE                               DATA     AGE
my-secret     kubernetes.io/dockerconfigjson     1        23s

Esegui il push dell'immagine container nel registro Harbor gestito

Per questo tutorial, scaricherai ed eseguirai il push dell'immagine del server web nginx nel registro Harbor gestito e la utilizzerai per eseguire il deployment di un'app server web nginx di esempio in un cluster Kubernetes. L'app server web nginx è disponibile nel repository pubblico Docker Hub.

  1. Esegui il pull dell'immagine nginx da Docker Hub alla tua workstation locale utilizzando una rete esterna:

    docker pull nginx

  2. Tagga l'immagine locale con il nome del repository:

    docker tag nginx ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25

  3. Esegui il push dell'immagine container nginx nel registro Harbor gestito:

    docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25

Crea un cluster Kubernetes

Ora che l'immagine container nginx è archiviata nel registro Harbor gestito e puoi accedervi, crea un cluster Kubernetes condiviso per eseguire il server web nginx.

Console

  1. Nel menu di navigazione, seleziona Kubernetes Engine > Cluster.

  2. Fai clic su Crea cluster.

  3. Nel campo Nome, specifica un nome per il cluster.

  4. Seleziona la zona in cui creare il cluster Kubernetes. Un cluster Kubernetes è una risorsa di zona e deve essere creata manualmente in ogni zona per garantire un'alta affidabilità.

  5. Fai clic su Collega progetto e seleziona un progetto da collegare al cluster. Quindi, fai clic su Salva.

  6. Fai clic su Crea.

  7. Attendi la creazione del cluster. Quando il cluster è disponibile per l'uso, lo stato READY viene visualizzato accanto al nome del cluster.

API

  1. Crea una risorsa personalizzata Cluster e salvala come file YAML, ad esempio cluster.yaml:

    apiVersion: cluster.gdc.goog/v1
kind: Cluster
metadata:
  name: CLUSTER_NAME
  namespace: platform

    Sostituisci il valore CLUSTER_NAME con il nome del cluster.

  2. Applica la risorsa personalizzata all'istanza GDC:

    kubectl create -f cluster.yaml --kubeconfig ${MANAGEMENT_API_SERVER}

  3. Collega un progetto al cluster Kubernetes utilizzando la console GDC. Al momento non puoi collegare un progetto al cluster utilizzando l'API.

Per saperne di più sulla creazione di un cluster Kubernetes condiviso, consulta Crea un cluster condiviso. Per saperne di più sulle opzioni di configurazione del cluster disponibili, consulta Configurazioni del cluster Kubernetes.

Esegui il deployment dell'app containerizzata di esempio

Ora puoi eseguire il deployment dell'immagine container nginx nel cluster Kubernetes.

Kubernetes rappresenta le applicazioni come risorse Pod, che sono unità scalabili che contengono uno o più container. Il pod è l'unità di deployment più piccola in Kubernetes. In genere, esegui il deployment dei pod come un set di repliche che possono essere scalate e distribuite insieme nel cluster. Uno dei modi per eseguire il deployment di un set di repliche è utilizzare un Deployment Kubernetes.

In questa sezione, creerai un Deployment Kubernetes per eseguire l'app containerizzata nginx nel cluster. Questo deployment ha repliche o pod. Un pod Deployment include un solo container: l'immagine container nginx. Creerai anche una risorsa Service che fornisce un modo stabile per i client di inviare richieste ai pod del Deployment.

Esegui il deployment del server web nginx nel cluster Kubernetes:

  1. Accedi al cluster Kubernetes e genera il relativo file kubeconfig con un'identità utente. Imposta il percorso kubeconfig come variabile di ambiente:

    export KUBECONFIG=CLUSTER_KUBECONFIG_PATH

  2. Crea ed esegui il deployment delle risorse personalizzate Deployment e Service di Kubernetes:

    kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
create -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
        ports:
        - containerPort: 80
      imagePullSecrets:
      - name: ${SECRET}
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - port: 80
      protocol: TCP
  type: LoadBalancer
EOF

  3. Verifica che i pod siano stati creati dal deployment:

    kubectl get pods -l app=nginx -n ${NAMESPACE}

    L'output è simile al seguente:

    NAME                                READY     STATUS    RESTARTS   AGE
nginx-deployment-1882529037-6p4mt   1/1       Running   0          1h
nginx-deployment-1882529037-p29za   1/1       Running   0          1h
nginx-deployment-1882529037-s0cmt   1/1       Running   0          1h

  4. Crea una policy di rete per consentire tutto il traffico di rete nello spazio dei nomi:

    kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
create -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  annotations:
  name: allow-all
spec:
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
  podSelector: {}
  policyTypes:
  - Ingress
EOF

  5. Esporta l'indirizzo IP per il servizio nginx:

      export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
      -n ${NAMESPACE} -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`

  6. Verifica l'indirizzo IP del server nginx utilizzando curl:

      curl http://$IP

Libera spazio

Per evitare che al tuo account GDC vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, devi eliminare le risorse che hai creato.

Elimina l'immagine container

Per eliminare l'immagine container dall'ambiente con air gap di GDC, elimina l'istanza Harbor che contiene l'immagine oppure mantieni l'istanza Harbor ed elimina la singola immagine container.

Per eliminare l'immagine container dal registro Harbor gestito, utilizza la console GDC:

  1. Nel menu di navigazione, seleziona Harbor Container Registry dalla sezione CI/CD.

  2. Fai clic sul link esterno Vai all'istanza Harbor.

  3. Elimina l'immagine container utilizzando l'interfaccia utente di Harbor. Per saperne di più, consulta Eliminare le istanze del registro Harbor.

Elimina l'app containerizzata

Per eliminare l'app containerizzata di cui hai eseguito il deployment, elimina il progetto GDC che contiene le risorse oppure mantieni il progetto GDC ed elimina le singole risorse.

Per eliminare le singole risorse:

  1. Elimina l'oggetto Service per l'app containerizzata:

    kubectl delete service nginx-service -n ${NAMESPACE}

  2. Elimina l'oggetto Deployment per l'app containerizzata:

    kubectl delete deployment nginx-deployment -n ${NAMESPACE}

  3. Se hai creato un cluster Kubernetes di test esclusivamente per questo tutorial, eliminalo:

    kubectl delete clusters.cluster.gdc.goog/USER_CLUSTER_NAME \
    -n platform --kubeconfig ${MANAGEMENT_API_SERVER}

    Questa operazione elimina le risorse che compongono il cluster Kubernetes, come le istanze di Compute, i dischi e le risorse di rete:

Passaggi successivi