Déploiements automatisés pour Azure Kubernetes Service (AKS)

Les déploiements automatisés simplifient le processus de configuration d’une action GitHub ou d’un pipeline Azure DevOps, ce qui facilite la création d’un pipeline de déploiement continu pour votre application vers Azure Kubernetes Service (AKS). Une fois connecté, chaque nouvelle validation déclenche automatiquement le pipeline, en fournissant des mises à jour à votre application en toute transparence. Vous pouvez apporter vos propres fichiers de déploiement pour la création rapide de pipelines ou générer des fichiers Dockerfiles et des manifestes Kubernetes pour conteneuriser et déployer des applications non conteneurisées avec un effort minimal.

Conditions préalables

• Un compte GitHub ou une organisation Azure DevOps.
• Un cluster AKS. Si vous n’en avez pas, vous pouvez en créer un à l’aide des étapes de déploiement d’un cluster Azure Kubernetes Service (AKS).
• Un registre de conteneurs Azure (ACR). Si vous n’en avez pas, vous pouvez en créer une en suivant les étapes de l’intégration d’Azure Container Registry (ACR) à un cluster Azure Kubernetes Service (AKS).
• Une application à déployer.

Se connecter au référentiel de code source

Créez un workflow de déploiement automatisé et autorisez-le à se connecter au référentiel de code source souhaité.

1. Dans le portail Azure, naviguez vers la ressource de votre cluster AKS.
2. Dans le menu du service, sous Paramètres, sélectionnez Déploiements automatisés>créer.
3. Sous Détails du référentiel, entrez un nom pour le flux de travail, puis sélectionnez GitHub ou ADO pour votre emplacement de dépôt.
4. Sélectionnez Autoriser l’accès pour se connecter au référentiel souhaité.
5. Choisissez le référentiel et la branche, puis sélectionnez Suivant.

Choisir la configuration de l’image conteneur

Pour préparer une application pour Kubernetes, vous devez la générer dans une image conteneur et la stocker dans un registre de conteneurs. Vous utilisez un fichier Dockerfile pour fournir des instructions sur la création de l’image conteneur. Si votre référentiel de code source n’a pas encore de fichier Dockerfile, les déploiements automatisés peuvent en générer un pour vous. Sinon, vous pouvez utiliser un fichier Dockerfile existant.

Sans fichier Dockerfile existant

Utilisez des déploiements automatisés pour générer un fichier Dockerfile pour de nombreux langages et frameworks tels que Go, C#, Node.js, Python, Java, Gradle, Clojure, PHP, Ruby, Erlang, Swift et Rust. La prise en charge du langage est basée sur ce qui est disponible dans draft.sh.

1. Sélectionnez Auto-containerize (générer dockerfile) pour la configuration du conteneur.
2. Sélectionnez l’emplacement où enregistrer le fichier Dockerfile généré dans le référentiel.
3. Sélectionnez l’environnement d’application dans la liste des langages et infrastructures pris en charge.
4. Entrez le port de l’application.
5. Fournissez le chemin du contexte de génération du Dockerfile.
6. Sélectionnez un Registre de conteneurs Azure existant ou créez-en un. Ce Registre est utilisé pour stocker l’image d’application générée.

Avec un fichier Dockerfile existant

Si votre référentiel de code possède déjà un fichier Dockerfile, vous pouvez le sélectionner pour être utilisé pour générer l’image de l’application.

1. Sélectionnez Dockerfile existant pour la configuration du conteneur.
2. Sélectionnez le fichier Dockerfile dans votre référentiel.
3. Entrez le contexte de build de Dockerfile pour passer l’ensemble de fichiers et de répertoires au processus de build. Ces fichiers sont utilisés pour générer l’image et sont inclus dans l’image finale, sauf s’ils sont ignorés par un .dockerignore fichier.
4. Sélectionnez un Registre de conteneurs Azure existant ou créez-en un. Ce Registre est utilisé pour stocker l’image d’application générée.

Choisir la configuration du manifeste Kubernetes

Remarque

L’option Générer des manifestes prend également en charge les fonctionnalités avancées telles que l’intégration de Service Connector, les ressources d’entrée générées automatiquement, ainsi que les fichiers manifestes Kubernetes personnalisables et plus détaillés.

Une application s’exécutant sur Kubernetes se compose de nombreux composants primitifs Kubernetes. Ces composants décrivent l’image conteneur à utiliser, le nombre de réplicas à exécuter, s’il existe une adresse IP publique requise pour exposer l’application, etc. Pour plus d’informations, consultez la [documentation Kubernetes][kubernetes-documentation]. Si votre référentiel de code source ne dispose pas déjà des manifestes Kubernetes de base à déployer, les déploiements automatisés peuvent les générer pour vous. Sinon, vous pouvez utiliser un ensemble de manifestes existants. Vous pouvez également choisir un graphique Helm existant.

Utiliser des manifestes Kubernetes existants

Si votre référentiel de code possède déjà un fichier Dockerfile, vous pouvez le sélectionner pour être utilisé pour générer l’image de l’application.

1. Sélectionnez Utiliser les fichiers de déploiement de manifeste Kubernetes existants pour les options de déploiement.
2. Sélectionnez le fichier manifeste ou le dossier Kubernetes à partir de votre dépôt.
3. Cliquez sur Suivant.

Utiliser un graphique Helm existant

Si votre référentiel de code dispose déjà d’un graphique Helm, vous pouvez le sélectionner pour être utilisé pour générer l’image de l’application.

1. Sélectionnez Utiliser le graphique Helm existant pour les options de déploiement.
2. Sélectionnez le dossier du chemin d’accès des graphiques à partir de votre référentiel.
3. Sélectionnez le chemin du fichier Values.yaml dans votre référentiel.
4. Si vous le souhaitez, fournissez des remplacements de graphique Helm.
5. Cliquez sur Suivant.

Générer des manifestes

Utilisez des déploiements automatisés pour générer un ensemble de fichiers manifeste Kubernetes de base pour que votre application soit opérationnelle. À l’heure actuelle, les déploiements automatisés créent un Deployment, un Serviceet un ConfigMap.

Les manifestes générés sont conçus pour appliquer des recommandations de [protections de déploiement][deployment-safeguards], notamment :

• Génération automatique des [probes liveness, readiness et startup][kubernetes-probes].
• Préférence pour l’[anti-affinité de pod][pod-anti-affinity] et les [contraintes de répartition topologique][topology-spread-constraints] qui répartissent les réplicas sur différents nœuds pour améliorer la résilience.
• Application du RuntimeDefault [profil informatique sécurisé][seccomp-profile] qui établit une couche supplémentaire de protection contre les vulnérabilités d’appel système courantes exploitées par des acteurs malveillants.
• Suppression de toutes les fonctionnalités Linux et autorisation d’un ensemble limité, conformément aux [normes de sécurité des pods Kubernetes][kubernetes-pod-security-standards] de la base de référence.

Les manifestes Kubernetes générés prennent également en charge l’ajout d’un connecteur d’entrée et de service. Ces intégrations facultatives seront abordées ci-dessous.

Pour générer des manifestes Kubernetes :

1. Sélectionnez Générer des fichiers de déploiement d’application pour les options de déploiement.
2. Entrez le port de l’application. Ce port est utilisé sur le port généré Service.
3. Sélectionnez l’emplacement où enregistrer les manifestes Kubernetes générés dans le référentiel.
4. (Facultatif) Modifiez les valeurs d’application et de configuration ou de service dans votre fichier manifeste en sélectionnant Modifier.
   1. Si vous ne souhaitez pas utiliser les valeurs par défaut recommandées par AKS, vous pouvez modifier différentes valeurs du fichier manifeste, telles que :
      • Demandes de mémoire/processeur
      • Limites de mémoire/processeur
      • Sondes de préparation et de démarrage TCP
      • Réplicas de mise à l’échelle minimum/maximum pour HPA
      • Utilisation de la mémoire/processeur pour HPA
      • Port de l'équilibrage de charge / Port cible
5. Cliquez sur Suivant.

(Facultatif) Utiliser une entrée managée et/ou un connecteur de service

Lorsque vous générez des manifestes Kubernetes avec des déploiements automatisés, vous pouvez éventuellement activer le routage des applications pour configurer un contrôleur d’entrée pour votre application. Vous pouvez également utiliser Service Connector pour créer une connexion ou intégrer en toute transparence votre application à un back-end de service Azure existant.

Exposer Ingress

Le routage des applications fournit un contrôleur d’entrée basé sur NGINX entièrement managé, complet avec le chiffrement SSL/TLS intégré à l’aide de certificats stockés dans Azure Key Vault et la gestion des zones DNS via Azure DNS. Lorsque vous utilisez des déploiements automatisés, la commande d’entrée d’exposition s’intègre en toute transparence avec le routage des applications, ce qui facilite l’exposition de votre application au trafic externe sous un nom DNS sécurisé et personnalisé, avec une configuration minimale.

1. Sélectionnez la case Exposer l'entrée.
2. Choisissez entre un contrôleur d’entrée existant ou un nouveau contrôleur d’entrée.
3. Choisissez entre utiliser un contrôleur d’entrée SSL/TLS activé ou non sécurisé .
4. (Facultatif) Entrez les détails du certificat si vous choisissez un contrôleur d’entrée activé par SSL/TLS .
5. Choisissez entre utiliser Azure DNS ou un fournisseur tiers.
6. Entrez la zone Azure DNS et le nom du sous-domaine.

Utiliser le connecteur de service

Service Connector vous aide à connecter votre application à d’autres services Azure de stockage. En configurant les paramètres réseau et les variables de connexion appropriés, il peut injecter automatiquement des informations d’identification dans votre application via des objets secrets Kubernetes sans configuration manuelle nécessaire. Pour en savoir plus sur Service Connector, consultez la documentation officielle.

1. Sélectionnez une connexion existante ou créez une connexion.
2. Lors de la création d’une connexion, vérifiez que vous remplissez tous les champs appropriés.

(Facultatif) Ajouter des variables d’environnement

Définissez des variables d’environnement pour un conteneur dans Kubernetes en spécifiant des paires nom-valeur. Les variables d’environnement sont importantes, car elles facilitent la gestion des paramètres, la gestion sécurisée des informations sensibles et la flexibilité dans les environnements.

Passer en revue la configuration et déployer

Passez en revue la configuration de l’application et les manifestes Kubernetes, puis sélectionnez Déployer. Une pull request (PR) sera générée sur le référentiel que vous avez sélectionné, alors ne quittez surtout pas la page de déploiement.

Vérifier et fusionner un pull request

Une fois le déploiement réussi, sélectionnez Afficher la demande de tirage pour afficher les détails de la demande de tirage générée sur votre référentiel de code.

1. Passez en revue les modifications apportées sous Fichiers et apportez les modifications souhaitées.
2. Sélectionnez Fusionner la pull request pour intégrer les modifications dans votre référentiel de code.

La fusion de la modification exécute le workflow GitHub Actions qui génère votre application dans une image conteneur, la stocke dans Azure Container Registry et la déploie sur le cluster.

Vérifier les ressources déployées

Une fois le pipeline terminé, vous pouvez passer en revue le Service Kubernetes créé dans le Portail Azure en sélectionnant Services et entrées sous la section Ressources Kubernetes du menu du service.

La sélection de l’adresse IP externe doit ouvrir une nouvelle page de navigateur avec l’application en cours d’exécution.

Supprimer des ressources

Une fois que vous avez terminé avec votre cluster, procédez comme suit pour éviter les frais Azure :

1. Dans le portail Azure, accédez aux déploiements automatisés
2. Sélectionnez ... dans le pipeline de votre choix.
3. Sélectionnez Supprimer.