Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment di un'app server web containerizzata

Questo tutorial descrive come caricare un'applicazione container in un ambiente appliance isolato da internet Google Distributed Cloud (GDC) ed eseguirla nell'ambiente appliance. In questo tutorial imparerai a creare progetti Harbor, caricare immagini in Harbor e creare carichi di lavoro. Un carico di lavoro in container viene eseguito all'interno di uno spazio dei nomi del progetto.

L'ambiente appliance GDC air-gapped include un registro Harbor preconfigurato chiamato tear-harbor in un progetto GDC chiamato tear. Utilizzerai questo registro in questo esempio.

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

Obiettivi

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

Prima di iniziare

Assicurati di avere un progetto per gestire i deployment containerizzati. Crea un progetto se non ne hai uno.
Imposta lo spazio dei nomi del progetto come variabile di ambiente:
```
export NAMESPACE=PROJECT_NAMESPACE
```
Scarica e installa gcloud CLI.
Chiedi all'amministratore IAM dell'organizzazione di concederti i seguenti ruoli:
- Ruolo Amministratore spazio dei nomi (namespace-admin) per lo spazio dei nomi del progetto. Questo ruolo è necessario per il deployment dei carichi di lavoro dei container nel tuo progetto.
- Ruolo di visualizzatore istanza Harbor (harbor-instance-viewer) per lo spazio dei nomi del tuo progetto. Questo ruolo è necessario per visualizzare e selezionare un'istanza Harbor.
- Ruolo Autore progetto Harbor (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
```

Crea un progetto Harbor nel registro

GDC fornisce Harbor as a Service, un servizio completamente gestito che 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 inserire 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
```
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 di 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 nessuno 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
```

Configura Docker

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

Configura Docker in modo che consideri attendibile Harbor as a Service. Per ulteriori informazioni, vedi Configurare Docker in modo che consideri attendibile la CA radice di Harbor.
Configura l'autenticazione Docker in Harbor. Per saperne di più, consulta la pagina Configurare l'autenticazione Docker per le istanze del registro Harbor.
Poiché tear-harbor è un registro Harbor preconfigurato, devi considerare attendibile il certificato firmato dalla CA interna air-gap di Google Distributed Cloud:
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 generalmente archiviato nel control plane 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.

Crea un secret di pull delle immagini Kubernetes

Poiché utilizzi un progetto Harbor privato, devi creare un secret di pull dell'immagine Kubernetes.

Aggiungi un account robot di 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 segreto:
```
docker login ${INSTANCE_URL}
```
Quando richiesto, inserisci il nome dell'account del progetto robot per Username e il token segreto per Password.
Imposta un nome arbitrario per il secret di pull dell'immagine:
```
export SECRET=SECRET
```
Crea il secret necessario per il pull dell'immagine:
```
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 del secret che crei.

Esegui il push dell'immagine container nel registro Harbor gestito

Per questo tutorial, scaricherai e invierai l'immagine del server web nginx al registro Harbor gestito e la utilizzerai per eseguire il deployment di un'app server web nginx di esempio in un cluster Kubernetes. L'app del server web nginx è disponibile nel registro di Artifact Registry pubblico. Google Cloud

Google Cloud

Esegui il pull dell'immagine nginx da Artifact Registry Google Cloud alla 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 completo dell'immagine è 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
```

Esegui il deployment dell'app container di esempio

Ora puoi eseguire il deployment dell'immagine container nginx nel cluster di 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, i pod vengono implementati come un insieme 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 tuo cluster. Questo deployment ha repliche o pod. Un pod Deployment contiene un solo container: l'immagine container nginx. Crea anche una risorsa Service che offre ai client un modo stabile per 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 un criterio di rete per consentire tutto il traffico di rete allo 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}'`

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

Passaggi successivi

Leggi la documentazione sui container per informazioni su come gestirli.