Esegui il deployment dei carichi di lavoro con container

Questa pagina descrive il processo di caricamento di un'immagine container in Harbor e il deployment di questa immagine nell'istanza sandbox GDC.

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 Remote Desktop o eseguire sshuttle sulla tua macchina Linux.

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

    • Amministratore secret (secret-admin): necessario per creare secret Kubernetes e operare nella console GDC.
    • Amministratore spazio dei nomi (namespace-admin): necessario per il deployment dei workload dei container nel tuo progetto.
    • Visualizzatore spazio dei nomi (namespace-viewer): necessario per visualizzare le risorse del progetto e dello spazio dei nomi.
    • Visualizzatore progetto (project-viewer): necessario per accedere alla console GDC e a Distributed Cloud CLI.
    • Visualizzatore istanza Harbor (harbor-instance-viewer): obbligatorio per visualizzare e selezionare un'istanza Harbor.
    • Autore progetto Harbor (harbor-project-creator): necessario per accedere a un progetto Harbor e gestirlo.
    • Project NetworkPolicy Admin (project-networkpolicy-admin): necessario per creare e gestire le policy di rete del progetto.

  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 la procedura descritta in Crea 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à implementata, 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

Carica l'immagine su Harbor

  1. Crea un progetto Harbor seguendo le istruzioni riportate 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 Accedi a Docker o Helm con i secret della CLI.

  3. Scarica o crea l'immagine container e segui le istruzioni air-gap di Google Distributed Cloud per trasferire un'immagine su Harbor.

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

    1. Accedi ed esegui il pull dal registro dei 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}

Esegui il deployment dell'app container

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

Crea una policy di rete

  1. Crea una policy 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 per il 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 seguente comando per creare un tunnel SSH. Se hai una sessione sshuttle esistente che hai creato quando ti sei connesso all'istanza, devi terminarla prima di eseguire il seguente comando:

      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}