Déployer une application sur GKE sur Azure

Cette page explique comment créer un cluster et un pool de nœuds, puis déployer un exemple d'application à l'aide de GKE sur Azure.

Compatibilité avec Terraform

Si vous connaissez Terraform, vous pouvez utiliser les scripts Terraform disponibles sur GitHub pour automatiser les prérequis et créer un cluster.

Avant de commencer

Avant de créer un cluster, vous devez remplir les conditions préalables. Vous devez fournir les ressources suivantes en particulier :

  • Un réseau virtuel Azure sur lequel le cluster sera exécuté.
  • Un sous-réseau pour les instances dupliquées du plan de contrôle Kubernetes.
  • Attributions de rôles Azure qui accorderont à GKE sur Azure l'accès à votre environnement Azure à l'aide d'un principal de service.
  • Ressource AzureClient que GKE sur Azure utilise pour s'authentifier auprès des services Azure et gérer les ressources de votre compte Azure.
  • Une paire de clés SSH permettant d'accéder aux machines virtuelles Azure du cluster.

Il vous incombe de créer et de gérer ces ressources, qui peuvent être partagées entre tous vos clusters. Toutes les autres ressources Azure sous-jacentes de votre cluster sont gérées par GKE sur Azure.

Configurer les paramètres par défaut de gcloud CLI

Utilisez la CLI gcloud pour configurer les paramètres par défaut de votre projet par défaut et de votre région Google Cloud.

Votre projet est associé à un ID de projet en tant qu'identifiant unique. Au moment de la création d'un projet, vous pouvez utiliser l'ID de projet généré automatiquement ou créer le vôtre.

Votre région Google Cloud est un emplacement à partir duquel vos clusters seront gérés. Par exemple, us-west1. Pour en savoir plus, consultez la section Régions de gestion.

Lorsque vous configurez ces paramètres par défaut, vous n'avez pas besoin de les inclure lorsque vous exécutez Google Cloud CLI. Vous pouvez également spécifier des paramètres ou ignorer les paramètres par défaut en transmettant les options --project et --location à Google Cloud CLI.

Lorsque vous créez des ressources GKE sur Azure après avoir configuré votre projet et votre emplacement par défaut, ces ressources sont automatiquement créées dans ce projet et cet emplacement.

Pour définir des valeurs par défaut, procédez comme suit :

  1. Définissez le projet par défaut :

    gcloud config set project PROJECT_ID

    Remplacez PROJECT_ID par l'ID du projet.

  2. Définissez l'emplacement de gestion par défaut :

    gcloud config set container_azure/location GOOGLE_CLOUD_LOCATION

    Remplacez GOOGLE_CLOUD_LOCATION par votre emplacement, par exemple us-west1.

Sélectionner des ID de ressource Azure pour votre cluster

Sélectionner un ID de groupe de ressources

Enregistrez le groupe de ressources du cluster dans une variable d'environnement en exécutant la commande suivante :

CLUSTER_RESOURCE_GROUP_ID=$(az group show --query id --output tsv \
    --resource-group=CLUSTER_RESOURCE_GROUP_NAME)

Remplacez CLUSTER_RESOURCE_GROUP_NAME par le nom du groupe de ressources dans lequel provisionner vos ressources de cluster, que vous avez configuré à l'étape Créer un groupe de ressources Azure.

Sélectionner un ID de réseau virtuel

Enregistrez l'ID VNet de votre cluster dans une variable d'environnement en exécutant la commande suivante :

VNET_ID=$(az network vnet show --query id --output tsv \
    --resource-group=VNET_RESOURCE_GROUP_NAME \
    --name=VNET_NAME)

Remplacez les éléments suivants :

Sélectionner un ID de sous-réseau

Enregistrez l'ID de sous-réseau de votre cluster dans une variable d'environnement en exécutant la commande suivante :

SUBNET_ID=$(az network vnet subnet show --query id --output tsv \
    --resource-group VNET_RESOURCE_GROUP_NAME \
    --vnet-name VNET_NAME \
    --name SUBNET_NAME)

Remplacez :

  • VNET_RESOURCE_GROUP_NAME par le nom d'un groupe de ressources existant contenant votre réseau virtuel. Il peut s'agir du nom du groupe de ressources que vous avez configuré dans la section Créer un réseau virtuel Azure.
  • VNET_NAME par le nom de votre réseau virtuel. Il peut s'agir du nom de votre réseau virtuel que vous avez configuré dans la section Créer un réseau virtuel Azure.
  • SUBNET_NAME par le nom de votre sous-réseau, par exemple, default.

Sélectionner des plages CIDR pour votre cluster

Kubernetes nécessite deux plages CIDR pour le cluster. Ces plages CIDR doivent être choisies de sorte qu'elles ne chevauchent pas les plages CIDR utilisées par vos sous-réseaux VPC. Elles doivent être suffisamment volumineuses pour la taille maximale attendue de votre cluster.

  • Plage CIDR d'adresses de pod : lorsqu'une ressource Pod est créée, une adresse IP de cette plage lui est attribuée. Exemple : plage 192.168.208.0/20

  • Plage CIDR d'adresses de service : lorsqu'une instance est créée, une adresse IP de cette plage lui est attribuée. Exemple : plage 192.168.224.0/20

Créer un cluster

Exécutez la commande suivante pour créer un cluster sous GKE sur Azure.

gcloud container azure clusters create azure-cluster-0 \
    --cluster-version 1.29.3-gke.600 \
    --azure-region AZURE_REGION \
    --fleet-project FLEET_PROJECT_ID \
    --client CLIENT_NAME \
    --resource-group-id $CLUSTER_RESOURCE_GROUP_ID \
    --vnet-id $VNET_ID \
    --subnet-id $SUBNET_ID \
    --pod-address-cidr-blocks POD_CIDR_BLOCK \
    --service-address-cidr-blocks SERVICE_CIDR_BLOCK \
    --ssh-public-key "SSH_PUBLIC_KEY" \
    --tags "google:gkemulticloud:cluster=azure-cluster-0"

Remplacez :

Pour obtenir plus d'informations et des paramètres facultatifs, consultez la page de référence gcloud container azure clusters create.

Créer un pool de nœuds

Créez un pool de nœuds à l'aide de Google Cloud CLI :

gcloud container azure node-pools create pool-0 \
    --cluster azure-cluster-0 \
    --node-version 1.29.3-gke.600 \
    --vm-size Standard_B2s \
    --max-pods-per-node 110 \
    --min-nodes 1 \
    --max-nodes 5 \
    --ssh-public-key "SSH_PUBLIC_KEY" \
    --subnet-id $SUBNET_ID \
    --tags "google:gkemulticloud:cluster=azure-cluster-0"

Remplacez SSH_PUBLIC_KEY par le texte de votre clé publique SSH, tel que créé à l'étape préalable à la création d'une paire de clés SSH. Si vous avez enregistré votre clé publique dans une variable d'environnement, vous pouvez utiliser ${SSH_PUBLIC_KEY}.

Afficher l'état de votre cluster

Après avoir créé un cluster et un pool de nœuds, vous pouvez afficher son état en utilisant Google Cloud CLI ou la console Google Cloud. Pour afficher l'état du cluster, faites votre choix entre Google Cloud CLI et la console Google Cloud, puis procédez comme suit :

gcloud

Utilisez la commande gcloud container azure clusters describe pour obtenir les détails de votre cluster :

gcloud container azure clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION

Remplacez les éléments suivants :

  • CLUSTER_NAME : nom de votre cluster.
  • GOOGLE_CLOUD_LOCATION : nom de l'emplacement Google Cloud qui gère le cluster

Console Google Cloud

  1. Dans la console Google Cloud, accédez à la page Présentation des clusters Google Kubernetes Engine.

    Accéder aux clusters GKE

  2. Vos clusters sont répertoriés par nom et emplacement.

  3. Cliquez sur le nom du cluster. Un panneau contenant des informations sur le cluster, y compris son état et ses fonctionnalités activées, s'affiche.

Obtenir des identifiants d'authentification pour le cluster

Après avoir créé votre cluster, vous devez obtenir des informations d'authentification pour interagir avec lui :

gcloud container azure clusters get-credentials azure-cluster-0

Cette commande configure kubectl pour l'accès au cluster que vous avez créé à l'aide de la passerelle Connect. Vous devez disposer d'au moins un pool de nœuds pour utiliser la passerelle Connect, car celle-ci repose sur l'agent Connect, qui s'exécute en tant que déploiement dans le cluster.

Déployer une application sur le cluster

Maintenant que vous avez créé un cluster, vous pouvez déployer une application conteneurisée dans celui-ci. Pour ce guide de démarrage rapide, vous pouvez déployer notre exemple d'application Web hello-app.

Vous utilisez des objets Kubernetes pour créer et gérer les ressources de votre cluster. Utilisez l'objet Déploiement pour déployer des applications sans état comme les serveurs Web. Les objets Service définissent les règles et les équilibreurs de charge permettant d'accéder à votre application via Internet.

Créer le déploiement

Pour exécuter hello-app dans votre cluster, vous devez déployer l'application en exécutant la commande suivante :

kubectl create deployment hello-server --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0

La commande Kubernetes kubectl create deployment crée un déploiement nommé hello-server. Le pod du déploiement exécute l'image de conteneur hello-app.

Dans cette commande :

  • --image désigne une image de conteneur à déployer. Dans cet exemple, la commande extrait l'exemple d'image d'un dépôt Artifact Registry, us-docker.pkg.dev/google-samples/containers/gke/hello-app. :1.0 indique la version de l'image à extraire. Si vous ne spécifiez pas de version, l'image avec le tag latest est utilisée.

Exposer le déploiement

Après avoir déployé l'application, vous devez l'exposer sur Internet afin que les utilisateurs puissent y accéder. Vous pouvez exposer cette application en créant un objet Service, c'est-à-dire une ressource Kubernetes permettant d'exposer votre application au trafic externe.

Pour exposer votre application, exécutez la commande kubectl expose suivante:

kubectl expose deployment hello-server --type LoadBalancer --port 80 --target-port 8080

L'option --type LoadBalancer permet de créer un équilibreur de charge Azure pour votre conteneur. L'option --port initialise le port public 80 sur Internet et l'option --target-port achemine le trafic vers le port 8080 de l'application.

Les équilibreurs de charge sont facturés selon la tarification d'Azure relative aux équilibreurs de charge.

Inspecter et afficher l'application

  1. Inspectez les pods en cours d'exécution à l'aide de la commande kubectl get pods :

    kubectl get pods

    Vous devriez voir un pod hello-server s'exécuter sur votre cluster.

  2. Inspectez le service hello-server à l'aide de la commande kubectl get service :

    kubectl get service hello-server

    À partir du résultat de cette commande, copiez l'adresse IP externe du service depuis la colonne EXTERNAL-IP.

  3. Consultez l'application dans votre navigateur Web à l'aide de l'adresse IP externe avec le port exposé :

    http://EXTERNAL-IP

Vous venez de déployer une application Web conteneurisée sur GKE sur Azure.

Effectuer un nettoyage

  1. Supprimez le service et le déploiement de l'application :

    kubectl delete service hello-server
kubectl delete deployment hello-server

  2. Supprimez votre pool de nœuds en exécutant la commande gcloud container azure node-pools delete :

    gcloud container azure node-pools delete pool-0 --cluster azure-cluster-0

  3. Supprimez votre cluster en exécutant la commande gcloud container azure clusters delete :

    gcloud container azure clusters delete azure-cluster-0

Étapes suivantes