Guida rapida di Kf

In questa guida rapida utilizzerai configurare un cluster GKE, installare Kf e le sue dipendenze, quindi eseguire il deployment di un'app Cloud Foundry di esempio.

Prima di iniziare

Panoramica

Nota: i cluster GKE Autopilot al momento non sono in grado di eseguire Kf. Utilizza un cluster GKE standard. Per saperne di più su queste modalità e su Autopilot, consulta la panoramica di Autopilot.

• Il tuo cluster GKE deve soddisfare i seguenti requisiti:

  • Facoltativo ma consigliato, il cluster deve essere dedicato a Kf. Ti consigliamo di installare solo Kf e le sue dipendenze per garantire la matrice di compatibilità viene mantenuta.

  • Almeno quattro nodi. Se devi aggiungere nodi, consulta Ridimensionamento di un cluster.

  • Il tipo di macchina minimo con almeno quattro vCPU, come e2-standard-4. Se il tipo di macchina per il cluster non ha almeno quattro vCPU, cambia il tipo di macchina come descritto Migrazione dei carichi di lavoro a tipi di macchine diversi.

  • (Facoltativo ma consigliato) registra il cluster in una canale di rilascio. Segui le istruzioni riportate in Registrare un cluster esistente in un canale di rilascio. se hai una versione GKE statica.

  • Workload Identity abilitato.

  • Artifact Registry abilitato.

  • Cloud Service Mesh (ASM).

  • Tekton installato. Per la versione, consulta Matrice di dipendenza.

  • Un account di servizio Google con il seguente criterio IAM (istruzioni per la creazione di cui trovi il link di seguito):

    • roles/iam.serviceAccountAdmin
    • serviceAccount:${CLUSTER_PROJECT}.svc.id.goog[kf/controller] (per il membro serviceAccount:${CLUSTER_PROJECT}.svc.id.goog[kf/controller])

La sezione Pulizia contiene istruzioni sull'eliminazione del cluster.

Abilita il supporto per Compute Engine

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

6. Abilitare l'API Compute Engine.

   Abilitare l'API

Abilita e configura GKE

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Attiva l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, install e poi inizializzare con gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente eseguendo gcloud components update.
  Nota: per gcloud CLI esistente di installazione, assicurati di impostare compute/region e compute/zone proprietà. Se imposti località predefinite, puoi evitare errori in gcloud CLI come i seguenti: One of [--zone, --region] must be supplied: Please specify location.

Crea e prepara un nuovo cluster GKE

Configura le variabili di ambiente

Nota: esporta queste variabili di ambiente nel terminale o in Cloud Shell per far funzionare i comandi successivi. Se ti disconnetti dall'ambiente shell e ti riconnetti in un secondo momento, devi configurare di nuovo le variabili.

Nota: prima di configurare le variabili di ambiente, assicurati di controllare la matrice delle dipendenze nella pagina Download Kf per la versione di Kf specificata.

Linux

export PROJECT_ID=YOUR_PROJECT_ID
export CLUSTER_PROJECT_ID=YOUR_PROJECT_ID
export CLUSTER_NAME=kf-cluster
export COMPUTE_ZONE=us-central1-a
export COMPUTE_REGION=us-central1
export CLUSTER_LOCATION=${COMPUTE_ZONE}
export NODE_COUNT=4
export MACHINE_TYPE=e2-standard-4
export NETWORK=default
export KF_VERSION=v2.1.0
export TEKTON_VERSION=v0.19.0

Windows PowerShell

Set-Variable -Name PROJECT_ID -Value YOUR_PROJECT_ID
Set-Variable -Name CLUSTER_PROJECT_ID -Value YOUR_PROJECT_ID
Set-Variable -Name CLUSTER_NAME -Value kf-cluster
Set-Variable -Name COMPUTE_ZONE -Value us-central1-a
Set-Variable -Name COMPUTE_REGION -Value us-central1
Set-Variable -Name CLUSTER_LOCATION -Value $COMPUTE_ZONE
Set-Variable -Name NODE_COUNT -Value 4
Set-Variable -Name MACHINE_TYPE -Value e2-standard-4
Set-Variable -Name NETWORK -Value default
Set-Variable -Name KF_VERSION -Value v2.1.0
Set-Variable -Name TEKTON_VERSION -Value v0.19.0

Creazione dell'account di servizio

Crea un account di servizio Google Cloud (GSA) che verrà associato a un account di servizio Kubernetes tramite Workload Identity. In questo modo non è necessario creare e inserire una chiave dell'account di servizio.

Nota: leggi attentamente le implicazioni per la sicurezza derivanti dall'utilizzo di Workload Identity nel documento Panoramica sulla sicurezza.

1. Crea l'account di servizio che verrà utilizzato da Kf.

   gcloud iam service-accounts create ${CLUSTER_NAME}-sa \
     --project=${CLUSTER_PROJECT_ID} \
     --description="GSA for Kf ${CLUSTER_NAME}" \
     --display-name="${CLUSTER_NAME}"

2. Consenti all'account di servizio di modificare il proprio criterio. Il controller Kf lo utilizzerà per aggiungere nuovi spazi (nomi) al criterio, consentendo il riutilizzo per Workload Identity.

   gcloud iam service-accounts add-iam-policy-binding ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com \
     --project=${CLUSTER_PROJECT_ID} \
     --role="roles/iam.serviceAccountAdmin" \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com"

3. Assegna il ruolo alle metriche di monitoraggio per l'accesso in scrittura a Cloud Monitoring.

   gcloud projects add-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter"

4. Concedi il ruolo di logging per l'accesso in scrittura a Cloud Logging.

   gcloud projects add-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/logging.logWriter"

Crea cluster GKE

Nota: a scopo dimostrativo, queste istruzioni utilizzano un cluster di zona. Per i deployment di produzione è consigliato un cluster a livello di regione.

gcloud container clusters create ${CLUSTER_NAME} \
  --project=${CLUSTER_PROJECT_ID} \
  --zone=${CLUSTER_LOCATION} \
  --num-nodes=${NODE_COUNT} \
  --machine-type=${MACHINE_TYPE} \
  --network=${NETWORK} \
  --addons=HttpLoadBalancing,HorizontalPodAutoscaling,NetworkPolicy \
  --enable-stackdriver-kubernetes \
  --enable-ip-alias \
  --enable-network-policy \
  --enable-autorepair \
  --enable-autoupgrade \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --release-channel=regular \
  --workload-pool="${CLUSTER_PROJECT_ID}.svc.id.goog" \
  --service-account="${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com"

Imposta regole firewall

Kf richiede che alcune porte del firewall siano aperte. Il nodo master deve essere in grado di comunicare con i pod sulle porte 80, 443, 8080, 8443 e 6443.

Abilita Workload Identity

Ora che hai un account di servizio e un cluster GKE, associa il cluster con il cluster.

gcloud iam service-accounts add-iam-policy-binding \
  "${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
  --project=${CLUSTER_PROJECT_ID} \
  --role="roles/iam.workloadIdentityUser" \
  --member="serviceAccount:${CLUSTER_PROJECT_ID}.svc.id.goog[kf/controller]"

Cluster GKE di destinazione

Configura l'accesso alla riga di comando kubectl eseguendo questo comando.

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --project=${CLUSTER_PROJECT_ID} \
    --zone=${CLUSTER_LOCATION}

Crea un repository Artifact Registry

1. Crea un Artifact Registry per l'archiviazione delle immagini container.

   gcloud artifacts repositories create ${CLUSTER_NAME} \
     --repository-format=docker \
     --location=${COMPUTE_REGION}

2. Concedi all'account di servizio l'autorizzazione nel repository Artifact Registry.

   gcloud artifacts repositories add-iam-policy-binding ${CLUSTER_NAME} \
     --location=${COMPUTE_REGION} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role='roles/artifactregistry.writer'

3. Configura l'autenticazione locale.

   gcloud auth configure-docker ${COMPUTE_REGION}-docker.pkg.dev

Installa le dipendenze software sul cluster

Nota: prima di installare qualsiasi cosa, assicurati di controllare la matrice delle dipendenze sul Pagina Download Kf per la versione Kf specificata.

1. Installa Service Mesh.

   Nota: consulta la matrice di dipendenza per trovare la versione corretta.

2. Installazione di Tekton:

   Nota: consulta la matrice di dipendenza per trovare la versione corretta.

   kubectl apply -f "https://github.com/tektoncd/pipeline/releases/download/${TEKTON_VERSION}/release.yaml"

Installazione di kf

1. Consulta Creare e preparare un cluster GKE per Kf per creare un cluster preparato per l'esecuzione di Kf.

2. Seleziona e annota la release Kf desiderata. Consulta la pagina Download Kf per conoscere le versioni disponibili

   Nota: molti dei comandi in questa guida dipendono da queste variabili di ambiente. Se ti disconnetti dall'ambiente shell e ti riconnetti in un secondo momento, dovrai configurare di nuovo le variabili.

3. Installa l'interfaccia a riga di comando:

   Linux

   Questa operazione installerà kf per tutti gli utenti del sistema. Segui le nella scheda Cloud Shell per installarlo autonomamente.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf-linux /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf
   

   Mac

   Questa operazione installerà kf per tutti gli utenti del sistema.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf-darwin /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf
   

   Cloud Shell

   Questa operazione installerà kf sulla tua istanza di Cloud Shell se utilizzi bash, potrebbe essere necessario modificare le istruzioni per altre shell.

   mkdir -p ~/bin
   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf-linux ~/bin/kf
   chmod a+x ~/bin/kf
   echo "export PATH=$HOME/bin:$PATH" >> ~/.bashrc
   source ~/.bashrc
   

   Windows

   Questa operazione scaricherà kf nella directory corrente. Aggiungila al percorso se voglio chiamare se da una posizione diversa dalla directory attuale.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf-windows.exe kf.exe
   

4. Installa i componenti del server:

   Linux e Mac

   kf.yaml verrà scaricato nella directory corrente.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf.yaml /tmp/kf.yaml
   kubectl apply -f /tmp/kf.yaml
   

   Windows

   kf.yaml verrà scaricato nella directory corrente.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf.yaml kf.yaml
   kubectl apply -f kf.yaml
   

5. Configura i secret:

   export WI_ANNOTATION=iam.gke.io/gcp-service-account=${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com
   
   kubectl annotate serviceaccount controller ${WI_ANNOTATION} \
   --namespace kf \
   --overwrite
   
   echo "{\"apiVersion\":\"v1\",\"kind\":\"ConfigMap\",\"metadata\":{\"name\":\"config-secrets\", \"namespace\":\"kf\"},\"data\":{\"wi.googleServiceAccount\":\"${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com\"}}" | kubectl apply -f -

6. Configura i valori predefiniti di Kf. Questi valori possono essere modificati in un secondo momento. L'esempio riportato di seguito utilizza modelli dominio con un provider DNS con caratteri jolly per assegnare a ogni spazio il proprio nome di dominio:

   export CONTAINER_REGISTRY=${COMPUTE_REGION}-docker.pkg.dev/${CLUSTER_PROJECT_ID}/${CLUSTER_NAME}
   export DOMAIN='$(SPACE_NAME).$(CLUSTER_INGRESS_IP).nip.io'
   
   kubectl patch configmaps config-defaults \
   -n=kf \
   -p="{\"data\":{\"spaceContainerRegistry\":\"${CONTAINER_REGISTRY}\",\"spaceClusterDomains\":\"- domain: ${DOMAIN}\"}}"

7. Convalida l'installazione:

   kf doctor --retries 10

   Nota: questo comando ispeziona il cluster per garantire che Kf e le sue dipendenze siano installati e funzionino. Verrà eseguita fino a 10 volte per dare al cluster Kubernetes il tempo di eseguire la riconciliazione e dovrebbe generare risultati in serie PASS. Se, dopo i nuovi tentativi, lo stato di un componente risulta FAIL, consulta la pagina Risoluzione dei problemi Kf.

Push di un'applicazione

Prerequisiti

Per completare questa sezione, è necessario:

1. Kf installato in un cluster GKE compatibile. Per le istruzioni, vedi Installare Kf.
2. Un elemento .kubeconfig che ha come target l'ammasso Kf. Se hai creato il cluster seguendo le istruzioni in questo documento, questa operazione sarà già eseguita. Puoi generare esplicitamente la configurazione con gcloud container clusters get-credentials ${CLUSTER_NAME} --zone ${CLUSTER_LOCATION}
3. L'interfaccia a riga di comando kf installata e nel tuo percorso. Per le istruzioni, vedi Installare Kf.
4. L'interfaccia a riga di comando git installata e nel tuo percorso.

Prepara spazio

1. Crea nuovo spazio:

   kf create-space test-space

2. Scegli come target lo spazio:

   kf target -s test-space

Esegui il push dell'app di test Cloud Foundry

1. Clona il repo di test-app:

   git clone https://github.com/cloudfoundry-samples/test-app go-test-app
   cd go-test-app

2. Esegui il push dell'app:

   kf push test-app

3. Trova l'URL dell'applicazione:

   1. Utilizza la formattazione di output per recuperare solo il percorso:

      kf app test-app --output 'jsonpath={.status.urls[0]}'

   2. Oppure questo, per un approccio CF più tradizionale:

      kf apps

   Nota: l'app ha impostato la proprietà percorso casuale.

4. Apri l'URL nel browser.

Esegui la pulizia

Questa procedura dovrebbe rimuovere tutti i componenti creati nel Sezione Crea e prepara un nuovo cluster GKE.

1. Elimina il cluster GKE:

   gcloud container clusters delete ${CLUSTER_NAME} --zone ${CLUSTER_LOCATION}

2. Elimina l'account di servizio Google:

   gcloud iam service-accounts delete ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com

3. Elimina le associazioni di criteri IAM:

   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/storage.admin"
   
   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/iam.serviceAccountAdmin"
   
   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter"

4. Elimina il repository di immagini container:

   gcloud artifacts repositories delete ${CLUSTER_NAME} \
     --location=${COMPUTE_REGION}