Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Esegui il deployment di un'app server web containerizzata

Questo tutorial descrive come caricare un'applicazione containerizzata in un ambiente appliance con air gap di Google Distributed Cloud (GDC) ed eseguirla in questo ambiente. Nell'ambito di questo tutorial, imparerai a creare progetti Harbor, caricare immagini in Harbor e creare carichi di lavoro. Un carico di lavoro containerizzato viene eseguito all'interno di uno spazio dei nomi del progetto.

L'ambiente appliance con air gap di GDC include un registro Harbor preconfigurato denominato tear-harbor in un progetto GDC denominato tear. In questo esempio utilizzerai questo registro.

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

Obiettivi

Eseguire il push di un'immagine container nel registro Harbor gestito.
Eseguire il deployment dell'app container di esempio nel cluster.

Prima di iniziare

Assicurati di avere un progetto per gestire i deployment containerizzati. Se non ne hai uno, creane uno.
Imposta lo spazio dei nomi del progetto come variabile di ambiente:
```
export NAMESPACE=PROJECT_NAMESPACE
```
Scarica e installa l'interfaccia a riga di comando gcloud.
Chiedi all'amministratore IAM dell'organizzazione di concederti i seguenti ruoli:
- Ruolo di amministratore dello spazio dei nomi (namespace-admin) per lo spazio dei nomi del progetto. Questo ruolo è necessario per eseguire il deployment dei carichi di lavoro containerizzati nel progetto.
- 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.
Accedi al cluster Kubernetes e genera il relativo file kubeconfig con un'identità utente. Assicurati di impostare il percorso kubeconfig come variabile di ambiente:
```
export KUBECONFIG=CLUSTER_KUBECONFIG
```

Creare un progetto Harbor nel registro

GDC 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 creare un progetto Harbor all'interno dell'istanza del registro tear-harbor per gestire le immagini container:

Devi avere l'URL di tear-harbor. Elenca l'URL dell'istanza:
```
gdcloud harbor instances describe tear-harbor --project=tear
```
L'output è simile a harbor-1.org-1.zone1.google.gdc.test.
Imposta l'URL dell'istanza come variabile da utilizzare più avanti nel tutorial:
```
export INSTANCE_URL=INSTANCE_URL
```
Inserisci l'URL dell'istanza senza il prefisso https://.
Prima di creare il progetto, devi accedere a Harbor utilizzando l'URL del passaggio precedente. Utilizza un browser per aprire questo URL e accedere all'istanza Harbor.
Crea il progetto Harbor:
```
gdcloud harbor harbor-projects create HARBOR_PROJECT \
    --project=tear \
    --instance=tear-harbor
```
Sostituisci HARBOR_PROJECT con il nome del progetto Harbor da creare. Non puoi creare il progetto Harbor in qualsiasi spazio dei nomi del progetto. Devi utilizzare il progetto tear.
Imposta il nome del progetto Harbor come variabile da utilizzare più avanti nel tutorial:
```
export HARBOR_PROJECT=HARBOR_PROJECT
```

Configurare Docker

Per utilizzare Docker nel registro Harbor, completa i seguenti passaggi:

Configura Docker in modo che consideri Harbor as a Service attendibile. Per saperne di più, consulta Configurare Docker in modo che consideri attendibile la CA radice di Harbor.
Configura l'autenticazione Docker in Harbor. Per saperne di più, consulta Configurare l'autenticazione Docker nelle istanze del registro Harbor.
Poiché tear-harbor è un registry Harbor preconfigurato, devi considerare attendibile il certificato firmato dalla CA interna di Google Distributed Cloud con air gap:
1. Chiedi al tuo IO le seguenti informazioni:
  1. L'URL esterno del cluster Harbor.
  2. Il file .crt della CA interna di Google Distributed Cloud con air gap. Il file viene in genere archiviato nel piano di controllo come secret con il nome trust-store-internal-only nello spazio dei nomi anthos-creds.
2. Analogamente al passaggio precedente, crea una cartella con il nome dell'URL esterno del cluster Harbor e mantieni il file .crt all'interno della cartella.

Creare un secret di pull delle immagini Kubernetes

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

Aggiungi un account robot del progetto Harbor. Segui i passaggi nell'interfaccia utente di Harbor per creare l'account robot e copiare il token secret del robot: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#add-a-robot-account.
Prendi nota del nuovo nome dell'account del progetto robot, che ha la seguente sintassi:
```
<PREFIX><PROJECT_NAME>+<ACCOUNT_NAME>
```
Ad esempio, il formato del nome dell'account del progetto robot è simile a harbor@library+artifact-account.

Per saperne di più su come trovare il nome dell'account del progetto robot in Harbor, consulta la documentazione di Harbor: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#view-project-robot-accounts.
Accedi a Docker con l'account robot del progetto Harbor e il token secret:
```
docker login ${INSTANCE_URL}
```
Quando richiesto, inserisci il nome dell'account del progetto robot per Username e il token secret per Password.
Imposta un nome arbitrario per il secret di pull delle immagini:
```
export SECRET=SECRET
```
Crea il secret necessario per il pull delle immagini:
```
kubectl create secret docker-registry ${SECRET}  \
    --from-file=.dockerconfigjson=DOCKER_CONFIG \
    -n NAMESPACE
```
Sostituisci quanto segue:
- DOCKER_CONFIG: il percorso del file .docker/config.json.
- NAMESPACE: lo spazio dei nomi per il secret che crei.

Eseguire 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 in Artifact Registry Google Cloud pubblico.

Esegui il pull dell'immagine nginx da Google Cloud Artifact Registry nella tua workstation locale utilizzando una rete esterna:
```
docker pull gcr.io/cloud-marketplace/google/nginx:1.25
```
Imposta il nome dell'immagine. Il formato di un nome immagine completo è il seguente:
```
${INSTANCE_URL}/${HARBOR_PROJECT}/nginx
```

Tagga l'immagine locale con il nome del repository:

docker tag gcr.io/cloud-marketplace/google/nginx:1.25 ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25

Esegui il push dell'immagine container nginx nel registro Harbor gestito:
```
docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
```

Eseguire il deployment dell'app container di esempio

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

Kubernetes rappresenta le applicazioni come risorse Pod, che sono unità scalabili che includono uno o più container. Il pod è l'unità più piccola di cui è possibile eseguire il deployment 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 container nginx sul cluster. Questo deployment ha repliche o pod. Un pod Deployment contiene un solo container: l'immagine container nginx. Crei anche una risorsa Service che fornisce un modo stabile per i client di inviare richieste ai pod del tuo Deployment.

Esegui il deployment del server web nginx:

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

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

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

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}'`

Verifica l'indirizzo IP del server nginx utilizzando curl:
```
  curl http://$IP
```

Passaggi successivi

Leggi la documentazione sui container per informazioni su come gestire i container.