Installazione di Kf

Questo documento descrive come configurare un cluster GKE, quindi installare Kf e le sue dipendenze.

Prima di iniziare

Panoramica

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

Requisiti per i cluster GKE.

• Facoltativo, ma consigliato, il cluster deve essere dedicato a Kf. Consigliamo di installare Kf e le sue dipendenze solo per garantire il mantenimento della matrice di compatibilità.

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

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

• (Facoltativo, ma consigliato) registra il cluster in un 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 (Identità carico di lavoro) attivata.

Requisiti Kf. La matrice delle dipendenze elenca le versioni specifiche.

• Artifact Registry.

• Anthos Service Mesh.

• Config Connector (Connettore configurazione).

• Tekton per Kf. Questo servizio non è rivolto agli utenti.

• Un account di servizio Google dedicato.

Nota: 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. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

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

4. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

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

6. Abilitare l'API Compute Engine.

   Abilita l'API

Abilita il supporto per Artifact Registry

1. Abilita l'API Artifact Registry.

   Abilita l'API Artifact Registry

Abilita e configura GKE

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

• Abilita l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installa e initialize gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente eseguendo gcloud components update.
  Nota: per le installazioni esistenti dell'interfaccia a riga di comando gcloud, assicurati di impostare le proprietà compute/region e compute/zone. Impostando le località predefinite, puoi evitare errori nellgcloud CLI come segue: One of [--zone, --region] must be supplied: Please specify location.

Prepara un nuovo cluster GKE e i servizi correlati

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, dovrai configurare nuovamente le variabili.

Linux e Mac

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} # Replace ZONE with REGION to switch
export NODE_COUNT=4
export MACHINE_TYPE=e2-standard-4
export NETWORK=default

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 # Replace ZONE with REGION to switch
Set-Variable -Name NODE_COUNT -Value 4
Set-Variable -Name MACHINE_TYPE -Value e2-standard-4
Set-Variable -Name NETWORK -Value default

Configurazione 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 e comprendi le implicazioni sulla sicurezza dell'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. Crea un nuovo ruolo IAM personalizzato.

   gcloud iam roles create serviceAccountUpdater \
   --project=${CLUSTER_PROJECT_ID} \
   --title "Service Account Updater" \
   --description "This role only updates members on a GSA" \
   --permissions iam.serviceAccounts.get,iam.serviceAccounts.getIamPolicy,iam.serviceAccounts.list,iam.serviceAccounts.setIamPolicy

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

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

4. Assegna il ruolo di monitoraggio alle metriche 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"

5. Assegna il ruolo 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 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 disponi di un account di servizio e di un cluster GKE, associa lo spazio dei nomi di identità del cluster al cluster.

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

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

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} \
     --project=${CLUSTER_PROJECT_ID} \
     --repository-format=docker \
     --location=${COMPUTE_REGION}

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

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

Installa le dipendenze software sul cluster

Nota: la matrice delle dipendenze nella pagina Download Kf contiene versioni bloccate per la versione Kf specificata.

1. Installa il mesh di servizi.

   1. Apri la guida all'installazione di Anthos Service Mesh.

   2. Assicurati che il menu a discesa della versione sia impostato sulla versione 1.9 di Anthos Service Mesh.

   3. Segui la guida per installare ASM.

2. Installa Config Connector.

   Nota: è necessario Config Connector a partire da Kf v2.4.0.
   Avviso: non utilizzare il metodo del componente aggiuntivo GKE per installare Config Connector, in quanto non è supportato da Kf. Segui questi passaggi di installazione personalizzati.

   1. Scarica il file tar dell'operatore di Config Connector richiesto.

      Nota: conserva una copia del bundle di installazione perché ti serve questo bundle per disinstallare Config Connector.

   2. Estrai il file tar.

      tar zxvf release-bundle.tar.gz
      

   3. Installa l'operatore di Config Connector sul cluster.

      kubectl apply -f operator-system/configconnector-operator.yaml
      

   4. Configura l'operatore di Config Connector.

      1. Copia il seguente codice YAML in un file denominato configconnector.yaml:

         Avviso: sostituisci la variabile KF_SERVICE_ACCOUNT_NAME nel codice YAML di seguito con l'account di servizio completo risolto da ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com

         # configconnector.yaml
         apiVersion: core.cnrm.cloud.google.com/v1beta1
         kind: ConfigConnector
         metadata:
           # the name is restricted to ensure that there is only one
           # ConfigConnector resource installed in your cluster
           name: configconnector.core.cnrm.cloud.google.com
         spec:
           mode: cluster
           googleServiceAccount: "KF_SERVICE_ACCOUNT_NAME" # Replace with the full service account resolved from ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com
         

      2. Applica la configurazione al cluster.

         kubectl apply -f configconnector.yaml

   5. Verifica che Config Connector sia installato completamente prima di continuare.

      • Config Connector esegue tutti i suoi componenti in uno spazio dei nomi denominato cnrm-system. Verifica che i pod siano pronti eseguendo questo comando:

        Nota: l'avvio del pod del controller può richiedere diversi minuti, pertanto questo comando potrebbe non funzionare immediatamente.

        kubectl wait -n cnrm-system --for=condition=Ready pod --all

      • Se Config Connector è installato correttamente, dovresti visualizzare un output simile al seguente:

        pod/cnrm-controller-manager-0 condition met
        pod/cnrm-deletiondefender-0 condition met
        pod/cnrm-resource-stats-recorder-86858dcdc5-6lqzb condition met
        pod/cnrm-webhook-manager-58c799b8fb-kcznq condition met
        pod/cnrm-webhook-manager-58c799b8fb-n2zpx condition met

   6. Configura Workload Identity.

      kubectl annotate serviceaccount \
      --namespace cnrm-system \
      --overwrite \
      cnrm-controller-manager \
      iam.gke.io/gcp-service-account=${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com

3. Installa Tekton:

   kubectl apply -f "https://storage.googleapis.com/tekton-releases/pipeline/previous/v0.23.0/release.yaml"

Installazione di Kf

Nota: assicurati che il cluster soddisfi i requisiti descritti in Creare e preparare un cluster GKE per Kf.

1. Installa l'interfaccia a riga di comando Kf:

   Linux

   Questo comando installa l'interfaccia a riga di comando Kf per tutti gli utenti nel sistema. Segui le istruzioni nella scheda Cloud Shell per installarla in modo autonomo.

   gsutil cp gs://kf-releases/v2.4.1/kf-linux /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf
   

   Mac

   Questo comando installa kf per tutti gli utenti del sistema.

   gsutil cp gs://kf-releases/v2.4.1/kf-darwin /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf
   

   Cloud Shell

   Questo comando installa kf sulla tua istanza di Cloud Shell se utilizzi bash; potrebbe essere necessario modificare le istruzioni per altre shell.

   mkdir -p ~/bin
   gsutil cp gs://kf-releases/v2.4.1/kf-linux ~/bin/kf
   chmod a+x ~/bin/kf
   echo "export PATH=$HOME/bin:$PATH" >> ~/.bashrc
   source ~/.bashrc
   

   Windows

   Questo comando scarica kf nella directory attuale. Aggiungila al percorso se vuoi effettuare chiamate da qualsiasi posizione diversa dalla directory corrente.

   gsutil cp gs://kf-releases/v2.4.1/kf-windows.exe kf.exe
   

2. Installa l'operatore:

   kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.4.1/operator.yaml"

3. Configura l'operatore per Kf:

   kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.4.1/kfsystem.yaml"

4. Configura secret e valori predefiniti:

   export CONTAINER_REGISTRY=${COMPUTE_REGION}-docker.pkg.dev/${CLUSTER_PROJECT_ID}/${CLUSTER_NAME}
   
   kubectl patch \
   kfsystem kfsystem \
   --type='json' \
   -p="[{'op': 'replace', 'path': '/spec/kf', 'value': {'enabled': true, 'config': {'spaceContainerRegistry': '${CONTAINER_REGISTRY}', 'secrets':{'workloadidentity':{'googleserviceaccount':'${CLUSTER_NAME}-sa', 'googleprojectid':'${CLUSTER_PROJECT_ID}'}}}}}]"
   

Convalida installazione

  kf doctor --retries=20

Nota: questo comando ispeziona il cluster per garantire che Kf e le sue dipendenze siano installati e funzionanti. Verrà eseguito fino a 20 volte per concedere al cluster Kubernetes il tempo di riconciliazione e dovrebbe comportare una serie di risultati PASS. Se, dopo i nuovi tentativi, lo stato di un componente restituisce FAIL, consulta la pagina Risoluzione dei problemi di Kf.

Esegui la pulizia

Questi passaggi devono rimuovere tutti i componenti creati nella sezione Creare e preparare un nuovo cluster GKE.

1. Elimina l'account di servizio Google:

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

2. 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"

3. Elimina il repository di immagini container:

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

4. Elimina il cluster GKE:

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