Versione 2.7

Versioni disponibili

2.11 - Ultima versione
2.10
2.9
2.7 - EOL/Non supportata
2.6 - EOL/Non supportata
2.8 - EOL/Non supportata
2.5 - EOL/Non supportata
2.4 - EOL/Non supportata
2.3 - EOL/Non supportata
2.2 - EOL/Non supportata
2.1 - EOL/Non supportata

Questa pagina è stata tradotta dall'API Cloud Translation.

Installa Kf su Google Cloud

Questo documento descrive come configurare un cluster GKE e poi installare Kf e le relative dipendenze.

Prima di iniziare

Requisiti del cluster GKE

Facoltativo, ma consigliato, il cluster deve essere dedicato a Kf. Ti consigliamo di installare solo Kf e le relative dipendenze per garantire la manutenzione 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, modificalo come descritto in Migrazione dei carichi di lavoro su tipi di macchine diversi.
Facoltativo, ma consigliato, registra il cluster in un canale di rilascio. Se hai una versione statica di GKE, segui le istruzioni riportate nella sezione Registrare un cluster esistente in un canale di rilascio.
Workload Identity abilitato.

Requisiti di Kf

Esamina e comprendi le autorizzazioni di accesso dei componenti in Kf nella pagina Dipendenze e architettura Kf.

La matrice delle dipendenze elenca le versioni specifiche.

Artifact Registry
Cloud Service Mesh
Config Connector
Tekton per l'utilizzo da parte di Kf; non si tratta di un servizio rivolto agli utenti
Un service account Google dedicato

Abilitare il supporto di Compute Engine

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Abilita l'API Compute Engine
Attiva l'API

Attivare il supporto di Artifact Registry

Abilita l'API Artifact Registry.
Abilita l'API Artifact Registry

Abilitare e configurare GKE

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

Attiva l'API Google Kubernetes Engine.

Attiva l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializzala. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.
Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti le località predefinite, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location.

Prepara un nuovo cluster GKE e i servizi correlati

Imposta le variabili di ambiente

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

Configura account di servizio

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

Crea il 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}"

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

Consenti al account di servizio di modificare il proprio criterio. Il controller Kf lo utilizzerà per aggiungere nuovi spazi dei nomi 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"

Assegna il ruolo di 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"

Assegna 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 un cluster GKE

gcloud container clusters create ${CLUSTER_NAME} \
  --project=${CLUSTER_PROJECT_ID} \
  --zone=${CLUSTER_LOCATION} \
  --num-nodes=${NODE_COUNT} \
  --machine-type=${MACHINE_TYPE} \
  --disk-size "122" \
  --network=${NETWORK} \
  --addons HorizontalPodAutoscaling,HttpLoadBalancing,GcePersistentDiskCsiDriver \
  --enable-dataplane-v2 \
  --enable-stackdriver-kubernetes \
  --enable-ip-alias \
  --enable-autorepair \
  --enable-autoupgrade \
  --scopes 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 l'apertura di alcune porte firewall. 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 lo spazio dei nomi dell'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 il seguente comando.

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

Crea un repository Artifact Registry

Crea un Artifact Registry per archiviare le immagini container.

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

Concedi all'account di servizio l'autorizzazione 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 su un cluster

Installa Cloud Service Mesh v1.12.
1. Segui la guida all'installazione di Cloud Service Mesh, inclusi i passaggi per creare un gateway in entrata.
Installa Config Connector.

Nota: Config Connector è obbligatorio 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. Utilizza questi passaggi di installazione personalizzata.
1. Scarica il file tar dell'operatore Config Connector richiesto.
  
  Nota :conserva una copia del bundle di installazione, in quanto ti servirà per disinstallare Config Connector.
2. Estrai il file tar.
```
tar zxvf release-bundle.tar.gz
```
3. Installa l'operatore Config Connector sul cluster.
```
kubectl apply -f operator-system/configconnector-operator.yaml
```
4. Configura l'operatore Config Connector.
  1. Copia il seguente codice YAML in un file denominato configconnector.yaml:
    
    Avviso: sostituisci la variabile KF_SERVICE_ACCOUNT_NAME nel file YAML riportato 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 completamente installato 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 controller Pod può richiedere diversi minuti, quindi 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
```

Installa Tekton:

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

Installazione di kf

Installa l'interfaccia a riga di comando Kf:
Linux
Questo comando installa l'interfaccia a riga di comando Kf per tutti gli utenti del sistema. Segui le istruzioni nella scheda Cloud Shell per installarlo solo per te.
```
gcloud storage cp gs://kf-releases/v2.7.3/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.
```
gcloud storage cp gs://kf-releases/v2.7.3/kf-darwin /tmp/kf
chmod a+x /tmp/kf
sudo mv /tmp/kf /usr/local/bin/kf
```
Cloud Shell
Questo comando installa kf nell'istanza di Cloud Shell se utilizzi bash, le istruzioni potrebbero dover essere modificate per altre shell.
```
mkdir -p ~/bin
gcloud storage cp gs://kf-releases/v2.7.3/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 corrente. Aggiungilo al percorso se vuoi chiamarlo da una directory diversa da quella corrente.
```
gcloud storage cp gs://kf-releases/v2.7.3/kf-windows.exe kf.exe
```

Installa l'operatore:

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

Configura l'operatore per Kf:

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

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 l'installazione

  kf doctor --retries=20

Esegui la pulizia

Questi passaggi dovrebbero rimuovere tutti i componenti creati nella sezione Crea e prepara un nuovo cluster GKE.

Elimina il service account Google:

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

Elimina le associazioni di policy IAM:

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"

Elimina il repository di immagini container:

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

Disinstalla Kf:

kubectl patch kfsystem kfsystem \
  --type='json' \
  -p="[{'op': 'replace', 'path': '/spec/kf', 'value': {'enabled': false, }}]"

(Facoltativo) Elimina il cluster GKE:

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