Esegui il deployment dei carichi di lavoro con container

Questa pagina descrive la procedura di caricamento di un'immagine container in Harbor e di deployment di questa immagine nell'istanza GDC Sandbox.

preparazione

  1. Segui le istruzioni riportate in Connettersi all'istanza per connetterti all'istanza con l'accesso alla riga di comando Linux. Puoi connetterti al gateway tramite Desktop remoto o eseguire sshuttle sulla tua macchina Linux.

  2. Chiedi all'amministratore IAM dell'organizzazione di concederti i seguenti ruoli a livello di progetto:

    • Amministratore dei secret (secret-admin): necessario per operare nella console GDC.
    • Amministratore dello spazio dei nomi (namepspace-admin): necessario per eseguire il deployment dei workload container nel progetto.
    • Amministratore PNP globale (global-project-networkpolicy-admin): necessario per creare e gestire le policy di rete del progetto tra le zone.
    • Visualizzatore progetto (project-viewer): necessario per accedere alla console GDC e a Google Distributed Cloud CLI.
    • Visualizzatore istanza Harbor (harbor-instance-viewer): necessario per visualizzare e selezionare un'istanza Harbor.
    • Creatore di progetti Harbor (harbor-project-creator): necessario per accedere e gestire un progetto Harbor.

  3. Imposta le variabili di ambiente che verranno utilizzate nelle istruzioni seguenti:

    export TENANT_PROJECT=TENANT_PROJECT # Intended deployment project for the container workflow.
export HARBOR_INSTANCE_NAME=HARBOR_INSTANCE_NAME # Harbor Container Registry instance name.
export HARBOR_PROJECT=HARBOR_PROJECT # Container registry project name for your images.
export AO_USER=AO_USER # Your user name in the instance, e.g.: fop-my-user@example.com.
export INSTANCE_URL=${HARBOR_INSTANCE_NAME}-${TENANT_PROJECT}.org-1.zone1.google.gdch.test.
export DOCKER_CONFIG_PATH=DOCKER_CONFIG_PATH # Path to docker config file e.g.: /root/.docker/config.json.

  4. Per creare un'istanza del registro Harbor, segui Creare un'istanza del registro Harbor, oppure puoi utilizzare l'istanza Harbor Sandbox precreata: il user-project predefinito in GDC Sandbox include un'istanza Harbor già sottoposta a deployment, user-haas-instance, che può essere utilizzata per lo sviluppo.

    export HARBOR_INSTANCE_NAME=user-haas-instance
export TENANT_PROJECT=user-project
export INSTANCE_URL=${HARBOR_INSTANCE_NAME}-${TENANT_PROJECT}.org-1.zone1.google.gdch.test

Caricare l'immagine in Harbor

  1. Crea un progetto Harbor seguendo la procedura descritta in Creare un progetto Harbor.

    Esempio:

    gdcloud harbor harbor-projects create HARBOR_PROJECT  \
--project=TENANT_PROJECT \
--instance=HARBOR_INSTANCE_NAME

  2. Accedi a Docker. Inizia da Accedere a Docker o Helm con i secret dell'interfaccia a riga di comando.

  3. Scarica o crea l'immagine container e segui le istruzioni di Google Distributed Cloud con air gap per eseguire il push di un'immagine in Harbor.

    Ad esempio, ecco un flusso di lavoro per eseguire il pull da GitLab e il push in Harbor:

    1. Accedi ed esegui il pull dal registro container GitLab.

      export GITLAB_ID=GITLAB_ID
export GITLAB_PROJECT_NAME=GITLAB_PROJECT_NAME
export GITLAB_IMAGE_PATH=registry.gitlab.com/GITLAB_ID/GITLAB_PROJECT_NAME
docker login registry.gitlab.com
docker pull ${GITLAB_IMAGE_PATH}

    2. Esegui il push dell'immagine GitLab in Harbor:

      export TAG=demo-image
docker tag ${TAG} ${GITLAB_IMAGE_PATH}
docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/${TAG}

Eseguire il deployment dell'app container

Continua con Creare un secret di pull dell'immagine Kubernetes per creare un secret ed eseguire il deployment dell'app.

Creare un criterio di rete

  1. Crea un criterio di rete per consentire tutto il traffico di rete al progetto tenant:

    kubectl --kubeconfig GLOBAL_API_KUBECONFIG -n TENANT_PROJECT \
create -f - <<EOF
apiVersion: networking.gdc.goog/v1
kind: ProjectNetworkPolicy
metadata:
  annotations:
  name: allow-all
spec:
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
  podSelector: {}
  policyTypes:
  - Ingress
EOF

Connettersi all'applicazione

  1. Esporta l'indirizzo IP del servizio:

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

  2. Per connetterti dalla tua macchina locale utilizzando sshuttle, esegui il comando seguente per creare un tunnel SSH. Se hai una sessione sshuttle esistente che hai creato quando ti sei connesso all'istanza, devi terminare la sessione prima di eseguire il comando seguente:

      sshuttle -r zone1-org-1-data@GDC_SANDBOX_INSTANCE_NAME --no-latency-control \
  --ssh-cmd 'gcloud compute ssh --project PROJECT_NAME --zone ZONE --tunnel-through-iap' \
  10.200.0.0/16 --dns

  3. Testa il servizio inviando una richiesta HTTP http://${IP}`:

      curl http://${IP}