Installer Kf sur Google Cloud

Ce document explique comment configurer un cluster GKE, puis comment installer Kf et ses dépendances.

Avant de commencer

Remarque : Les clusters GKE Autopilot ne sont actuellement pas en mesure d'exécuter Kf. Utilisez un cluster GKE standard. Pour plus d'informations sur ces modes et pour en savoir plus sur Autopilot, consultez la page Présentation d'Autopilot.

Configuration requise pour les clusters GKE

• Le cluster doit être dédié à Kf, mais cela n'est pas obligatoire. Nous vous recommandons de n'installer que Kf et ses dépendances pour vous assurer que la matrice de compatibilité est maintenue.

• Au moins quatre nœuds. Si vous devez ajouter des nœuds, consultez la page Redimensionner un cluster.

• Type de machine minimal comportant au moins quatre processeurs virtuels, tels que e2-standard-4. Si le type de machine de votre cluster ne comporte pas au moins quatre processeurs virtuels, modifiez le type de machine comme décrit dans la section Migrer des charges de travail vers différents types de machines.

• Nous vous recommandons d'inscrire le cluster dans une version disponible, mais cela n'est pas obligatoire. Suivez les instructions de la page Enregistrer un cluster existant dans une version disponible si vous disposez d'une version GKE statique.

• Workload Identity activé.

Prérequis pour Kf

Examiner et comprendre les autorisations d'accès des composants dans Kf sur la page Dépendances et architecture de Kf.

La matrice de dépendances répertorie les versions spécifiques.

• Artifact Registry

• Cloud Service Mesh

• Config Connector

• Tekton, pour une utilisation par Kf (il ne s'agit pas d'un service destiné aux utilisateurs)

• Un compte de service Google dédié

Remarque : La section Effectuer un nettoyage fournit des instructions sur la suppression du cluster.

Activer la compatibilité avec Compute Engine

1. 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.

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. Make sure that billing is enabled for your Google Cloud project.

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. Make sure that billing is enabled for your Google Cloud project.

6. Activez l'API Compute Engine.

   Activer l'API

Activer la compatibilité avec Artifact Registry

1. Activez l'API Artifact Registry.

   Activer l'API Artifact Registry

Activer et configurer GKE

Avant de commencer, effectuez les tâches suivantes :

• Activez l'API Google Kubernetes Engine.
Activer l'API Google Kubernetes Engine
• Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
  Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Préparer un nouveau cluster GKE et les services associés

Configurer des variables d'environnement

Remarque : Exportez ces variables d'environnement dans votre environnement ou Cloud Shell pour que les commandes suivantes fonctionnent. Si vous vous déconnectez de votre environnement shell, puis que vous vous reconnectez ultérieurement, vous devez configurer à nouveau les variables.

Linux et 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

Configurer un compte de service

Créez un compte de service Google Cloud qui sera associé à un compte de service Kubernetes via Workload Identity. Cela évite de devoir créer et injecter une clé de compte de service.

Remarque : Veillez à bien comprendre l'impact de l'utilisation de Workload Identity sur la sécurité en lisant le document Présentation des fonctionnalités de sécurité.

1. Créez le compte de service que Kf utilisera.

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

2. Créez un rôle IAM personnalisé.

   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. Autorisez le compte de service à modifier sa propre stratégie. Le contrôleur Kf l'utilise pour ajouter de nouveaux espaces (de noms) à la règle, ce qui permet ainsi la réutilisation de 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. Attribuez un rôle de surveillance des métriques pour l'accès en écriture à 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. Accordez un rôle de journalisation pour l'accès en écriture à 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"

Créer un cluster GKE

Remarque : À des fins de démonstration, ces instructions utilisent un cluster zonal. Pour les déploiements de production, il est recommandé d'utiliser un cluster régional.

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"

Définir des règles de pare-feu

Kf nécessite l'ouverture de certains ports de pare-feu. Le nœud maître doit pouvoir communiquer avec les pods sur les ports 80, 443, 8080, 8443 et 6443.

Activer Workload Identity

Maintenant que vous disposez d'un compte de service et d'un cluster GKE, associez l'espace de noms d'identité du cluster au 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"

Cibler le cluster GKE

Configurez l'accès à l'outil ligne de commande kubectl en exécutant la commande suivante :

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

Créer un dépôt Artifact Registry

1. Créez un dépôt Artifact Registry pour stocker les images de conteneurs.

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

2. Accordez l'autorisation de compte de service sur le dépôt 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'

Installer des dépendances logicielles sur un cluster

Remarque : La matrice de dépendances sur la page Téléchargements Kf a épinglé les versions de la version de Kf donnée.

1. Installez Cloud Service Mesh v1.23.3-asm.1+config1.

   Remarque : Lors de l'installation de passerelles à l'aide du document ASM, veuillez sélectionner l'option "Libellé de révision" à l'étape 2, car elle est compatible avec Kf.
   1. Suivez le guide d'installation Cloud Service Mesh, y compris la procédure de création de passerelle d'entrée.

2. Installez Config Connector.

   Remarque : Config Connector est requis à partir de Kf v2.4.0.
   Avertissement : N'utilisez pas la méthode complémentaire GKE pour installer Config Connector, car il n'est pas compatible avec Kf. Veuillez suivre ces étapes d'installation personnalisées.

   1. Téléchargez le fichier tar de l'opérateur Config Connector requis :

      Remarque : Conservez une copie du groupe d'installation. Vous en aurez besoin pour désinstaller Config Connector
      .

   2. Extrayez le fichier tar.

      tar zxvf release-bundle.tar.gz

   3. Installez l'opérateur Config Connector sur votre cluster.

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

   4. Configurer l'opérateur Config Connector

      1. Copiez le fichier YAML suivant dans un fichier nommé configconnector.yaml :

         Avertissement : Remplacez la variable KF_SERVICE_ACCOUNT_NAME de la configuration YAML ci-dessous par le compte de service complet résolu à partir de ${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. Appliquez la configuration à votre cluster.

         kubectl apply -f configconnector.yaml

   5. Vérifiez que Config Connector est entièrement installé avant de continuer.

      • Config Connector exécute tous ses composants dans un espace de noms nommé cnrm-system. Vérifiez que les pods sont prêts en exécutant la commande suivante :

        Remarque : Le démarrage du pod contrôleur peut prendre plusieurs minutes. Il est donc possible que cette commande ne fonctionne pas immédiatement.

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

      • Si Config Connector est correctement installé, vous devriez obtenir un résultat qui ressemble à ce qui suit :

        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. Configurer 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. Installez Tekton :

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

Installer Kf

Remarque : Assurez-vous que votre cluster remplit les conditions requises dans Créer et préparer un cluster GKE pour Kf.

1. Installez la CLI Kf :

   Linux

   Cette commande installe la CLI Kf pour tous les utilisateurs du système. Suivez les instructions de l'onglet Cloud Shell pour l'installer juste pour vous.

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

   Mac

   Cette commande installe kf pour tous les utilisateurs du système.

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

   Cloud Shell

   kf sera installé sur votre instance Cloud Shell si vous utilisez bash, et vous devrez peut-être modifier les instructions pour les autres interfaces système.

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

   Windows

   Cette commande télécharge kf dans le répertoire actuel. Si vous souhaitez l'appeler depuis un emplacement autre que le répertoire actuel, ajoutez-le au chemin d'accès.

   gcloud storage cp gs://kf-releases/v2.11.27/kf-windows.exe kf.exe

2. Installez l'opérateur :

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

3. Configurez l'opérateur pour Kf :

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

4. Configurez les secrets et les valeurs par défaut :

   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}'}}}}}]"
   

Valider l'installation

  kf doctor --retries=20

Remarque : Cette commande inspectera le cluster pour s'assurer que Kf et ses dépendances sont installés et fonctionnent. Elle s'exécute jusqu'à 20 fois afin de laisser le temps au cluster Kubernetes d'effectuer le rapprochement. La commande doit générer une série de résultats à l'état PASS. Si l'état d'un composant est FAIL après plusieurs tentatives, consultez la page Résoudre les problèmes liés à Kf.

Nettoyer

Cette procédure permet de supprimer tous les composants créés dans la section Créer et préparer un cluster GKE.

1. Supprimez le compte de service Google :

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

2. Supprimez les liaisons de stratégie 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"

3. Supprimez le dépôt d'images de conteneurs :

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

4. Désinstallez Kf :

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

5. (Facultatif) Supprimez le cluster GKE :

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