Guide de démarrage rapide de Kf

Dans ce guide de démarrage rapide, vous allez configurer un cluster GKE, installer Kf et ses dépendances, puis déployer un exemple d'application Cloud Foundry.

Avant de commencer

Présentation

Remarque : Les clusters GKE Autopilot ne sont actuellement pas en mesure d'exécuter Kf. Veuillez utiliser 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.

• Votre cluster GKE doit répondre aux exigences suivantes :

  • 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é.

  • Artifact Registry activé.

  • Cloud Service Mesh (ASM)

  • Tekton installé. Consultez la matrice de dépendances pour la version.

  • Un compte de service Google avec la stratégie IAM suivante (instructions de création ci-dessous) :

    • roles/iam.serviceAccountAdmin
    • serviceAccount:${CLUSTER_PROJECT}.svc.id.goog[kf/controller] (pour le membre serviceAccount:${CLUSTER_PROJECT}.svc.id.goog[kf/controller])

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

Créer et préparer un cluster GKE

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 et que vous vous reconnectez par la suite, vous devez de nouveau configurer les variables.

Remarque : Avant de configurer les variables d'environnement, assurez-vous de vérifier la matrice de dépendances sur la page Téléchargements Kf pour la version de Kf concernée.

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.2.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.2.0
Set-Variable -Name TEKTON_VERSION -Value v0.19.0

Configurer un compte de service

Créez un compte de service GCP (GSA) 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 : Veuillez lire les conséquences de l'utilisation de Workload Identity sur la sécurité dans 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. 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 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. 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"

4. 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} \
  --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"

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 \
  "${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]"

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} \
     --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} \
     --location=${COMPUTE_REGION} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role='roles/artifactregistry.writer'

3. Configurez votre authentification locale.

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

Installer des dépendances logicielles sur le cluster

Remarque : Avant d'installer quoi que ce soit, veillez à vérifier la matrice de dépendances sur la page Téléchargements Kf de la version Kf donnée.

1. #install-service-mesh

   Remarque : Pour connaître la version appropriée, consultez la matrice des dépendances.

2. Installez Tekton :

   Remarque : Pour connaître la version appropriée, consultez la matrice des dépendances.

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

Installer Kf

1. Consultez la section Créer et préparer un cluster GKE pour Kf afin de créer un cluster prêt à exécuter Kf.

2. Sélectionnez et notez la version de Kf souhaitée. Consultez la page Téléchargements Kf pour connaître les versions disponibles.

   Remarque : De nombreuses commandes de ce guide dépendent de ces variables d'environnement. Si vous vous déconnectez de votre environnement shell, puis que vous vous reconnectez ultérieurement, vous devrez configurer à nouveau les variables.

3. Installez la CLI :

   Linux

   kf sera installé 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/${KF_VERSION}/kf-linux /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf

   Mac

   kf sera installé pour tous les utilisateurs du système.

   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

   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/${KF_VERSION}/kf-linux ~/bin/kf
   chmod a+x ~/bin/kf
   echo "export PATH=$HOME/bin:$PATH" >> ~/.bashrc
   source ~/.bashrc

   Windows

   Cela téléchargera kf sur 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/${KF_VERSION}/kf-windows.exe kf.exe

4. Installez les composants du serveur :

   Linux et Mac

   Cela téléchargera le fichier kf.yaml dans le répertoire actuel.

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

   Windows

   Cela téléchargera le fichier kf.yaml dans le répertoire actuel.

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

5. Secrets de configuration :

   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. Définissez les valeurs par défaut de Kf. Ces valeurs peuvent être modifiées ultérieurement. L'exemple ci-dessous utilise des modèles de domaine avec un fournisseur DNS générique pour fournir à chaque espace son propre nom de domaine :

   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. Validez l'installation :

   kf doctor --retries 10

   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'à 10 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.

Déployer une application

Prérequis

Pour cette section, les éléments suivants sont requis :

1. Kf doit être installé dans un cluster GKE compatible. Consultez la section Installer Kf pour obtenir la marche à suivre.
2. .kubeconfig ciblant le cluster Kf. Si vous avez créé le cluster en suivant les instructions de ce document, alors cela est déjà effectué. Vous pouvez générer explicitement la configuration à l'aide de l'option gcloud container clusters get-credentials ${CLUSTER_NAME} --zone ${CLUSTER_LOCATION}.
3. La CLI kf doit être installée dans votre chemin d'accès. Consultez la section Installer Kf pour obtenir la marche à suivre.
4. La CLI git doit être installée dans votre chemin d'accès.

Préparer l'espace

1. Créez un espace :

   kf create-space test-space

2. Ciblez l'espace :

   kf target -s test-space

Déployer l'application de test Cloud Foundry

1. Clonez le dépôt test-app :

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

2. Déployez l'application :

   kf push test-app

3. Recherchez l'URL de l'application :

   1. Utilisez le format de sortie pour ne récupérer que la route :

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

   2. Ou pour une approche CF plus classique :

      kf apps

   Remarque : L'application a défini la propriété de routage aléatoire.

4. Ouvrez l'URL dans votre navigateur.

Effectuer un nettoyage

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 cluster GKE :

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

2. Supprimez le compte de service Google :

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

3. 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/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. Supprimez le dépôt d'images de conteneurs :

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