Installer Kf sur Google Cloud

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

Avant de commencer

Configuration requise pour les clusters GKE

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.

Activer la compatibilité avec Compute Engine

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud 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.

    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.

Configurer des variables d'environnement

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.

  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

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

  1. Installez Cloud Service Mesh v1.12.

    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.

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

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

        # 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 :

        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.32.1/release.yaml"

Installer 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.9.0/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.9.0/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.9.0/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.9.0/kf-windows.exe kf.exe
    
  2. Installez l'opérateur :

    kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.9.0/operator.yaml"
  3. Configurez l'opérateur pour Kf :

    kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.9.0/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

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}