Esegui il deployment di un'app server web containerizzata

Crea un registro Harbor gestito

GDC air-gapped 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 dei container Harbor, completa i seguenti passaggi:

Crea un progetto Harbor nel registro

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

Configura Docker

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

1. 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.

2. Configura l'autenticazione Docker in Harbor. Per saperne di più, consulta la pagina 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. Nella console Harbor, seleziona il tuo progetto Harbor.

   2. Fai clic su Robot Accounts (Account robot).

   3. Seleziona New Robot Account (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 segreto dell'account robot vengono visualizzati nella schermata di operazione riuscita. Tieni aperta questa schermata come riferimento per il passaggio successivo.

   Per ulteriori informazioni, 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 e il token segreto del progetto Harbor:

   docker login ${INSTANCE_URL}
   

   Quando richiesto, inserisci il nome del progetto robot per il nome utente e il token segreto per la password forniti nel passaggio precedente dalla schermata di conferma della console Harbor.

3. Imposta un nome arbitrario per il secret di pull dell'immagine:

   export SECRET=SECRET
   

4. Crea il secret necessario per il pull dell'immagine:

   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 tuo 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 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 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 per eseguire il server web Nginx.

Per ulteriori informazioni sulla creazione di un cluster Kubernetes, consulta Crea un cluster Kubernetes.

Esegui il deployment dell'app container 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 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. Puoi anche creare 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 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 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
   

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. Testa l'indirizzo IP del server nginx utilizzando curl:

     curl http://$IP