Concepts de base de Kubernetes pour AKS (Azure Kubernetes Service)Kubernetes core concepts for Azure Kubernetes Service (AKS)

Le développement d’applications adoptant progressivement une approche basée sur les conteneurs, il est important et nécessaire d’orchestrer et de gérer les ressources.As application development moves towards a container-based approach, the need to orchestrate and manage resources is important. Kubernetes est la plateforme leader du marché qui offre la possibilité de fournir une planification fiable des charges de travail d’applications à tolérance de panne.Kubernetes is the leading platform that provides the ability to provide reliable scheduling of fault-tolerant application workloads. AKS (Azure Kubernetes Service) est une offre Kubernetes managés qui simplifie la gestion et le déploiement des applications basées sur des conteneurs.Azure Kubernetes Service (AKS) is a managed Kubernetes offering that further simplifies container-based application deployment and management.

Cet article présente les principaux composants de l’infrastructure Kubernetes, tels que le plan de contrôle, les nœuds et les pools de nœuds.This article introduces the core Kubernetes infrastructure components such as the control plane, nodes, and node pools. Les ressources de charge de travail telles que les pods, les déploiements et les ensembles sont également présentées, ainsi que le regroupement de ressources dans des espaces de noms.Workload resources such as pods, deployments, and sets are also introduced, along with how to group resources into namespaces.

Présentation de KubernetesWhat is Kubernetes?

Kubernetes est une plateforme évoluant rapidement qui gère les applications basées sur les conteneurs, ainsi que leurs composants de mise en réseau et de stockage.Kubernetes is a rapidly evolving platform that manages container-based applications and their associated networking and storage components. L’accent est mis sur les charges de travail d’applications, pas sur les composants de l’infrastructure sous-jacente.The focus is on the application workloads, not the underlying infrastructure components. Kubernetes fournit une approche déclarative des déploiements, assortie d’un ensemble robuste d’API pour les opérations de gestion.Kubernetes provides a declarative approach to deployments, backed by a robust set of APIs for management operations.

Vous pouvez générer et exécuter des applications modernes, portables et basées sur des microservices qui bénéficient de l’orchestration et de la gestion par Kubernetes de la disponibilité des composants d’application.You can build and run modern, portable, microservices-based applications that benefit from Kubernetes orchestrating and managing the availability of those application components. Kubernetes prend en charge les applications sans état et avec état à mesure que les équipes adoptent les applications basées sur des microservices.Kubernetes supports both stateless and stateful applications as teams progress through the adoption of microservices-based applications.

En tant que plateforme ouverte, Kubernetes vous permet de créer des applications avec vos langage de programmation, système d’exploitation, bibliothèques ou bus de messagerie préférés.As an open platform, Kubernetes allows you to build your applications with your preferred programming language, OS, libraries, or messaging bus. Les outils d’intégration et de livraison continues (CI/CD) existants peuvent s’intégrer à Kubernetes dans le cadre de la planification et du déploiement de versions.Existing continuous integration and continuous delivery (CI/CD) tools can integrate with Kubernetes to schedule and deploy releases.

AKS (Azure Kubernetes Service) fournit un service Kubernetes managé qui réduit la complexité des tâches de gestion principales et de déploiement, y compris la coordination des mises à niveau.Azure Kubernetes Service (AKS) provides a managed Kubernetes service that reduces the complexity for deployment and core management tasks, including coordinating upgrades. Le plan de contrôle AKS est géré par la plateforme Azure ; vous ne payez que pour les nœuds AKS qui exécutent vos applications.The AKS control plane is managed by the Azure platform, and you only pay for the AKS nodes that run your applications. AKS repose sur le moteur open source Azure Kubernetes Service (aks-engine).AKS is built on top of the open-source Azure Kubernetes Service Engine (aks-engine).

Architecture d’un cluster KubernetesKubernetes cluster architecture

Un cluster Kubernetes comprend deux composants :A Kubernetes cluster is divided into two components:

  • Les nœuds de plan de contrôle fournissent les services Kubernetes de base et l’orchestration des charges de travail d’applications.Control plane nodes provide the core Kubernetes services and orchestration of application workloads.
  • Les nœuds exécutent vos charges de travail d’applications.Nodes run your application workloads.

Plan de contrôle et composants de nœud Kubernetes

Plan de contrôleControl plane

Quand vous créez un cluster AKS, un plan de contrôle est automatiquement créé et configuré.When you create an AKS cluster, a control plane is automatically created and configured. Ce plan de contrôle est fourni en tant que ressource Azure managée tirée de l’utilisateur.This control plane is provided as a managed Azure resource abstracted from the user. Il n’existe aucun coût lié au plan de contrôler ; seuls les nœuds qui font partie du cluster AKS occasionnent des frais.There's no cost for the control plane, only the nodes that are part of the AKS cluster.

Le plan de contrôle inclut les composants Kubernetes principaux suivants :The control plane includes the following core Kubernetes components:

  • kube-apiserver : le serveur d’API détermine la façon dont les API Kubernetes sous-jacentes sont exposées.kube-apiserver - The API server is how the underlying Kubernetes APIs are exposed. Ce composant fournit l’interaction des outils de gestion, tels que kubectl ou le tableau de bord Kubernetes.This component provides the interaction for management tools, such as kubectl or the Kubernetes dashboard.
  • etcd : pour maintenir l’état de la configuration et du cluster Kubernetes, le composant etcd hautement disponible est un magasin de valeurs essentiel dans Kubernetes.etcd - To maintain the state of your Kubernetes cluster and configuration, the highly available etcd is a key value store within Kubernetes.
  • kube-scheduler : quand vous créez ou mettez à l’échelle des applications, le planificateur détermine les nœuds pouvant exécuter la charge de travail et les démarre.kube-scheduler - When you create or scale applications, the Scheduler determines what nodes can run the workload and starts them.
  • kube-controller-manager : le gestionnaire de contrôleurs surveille une série de contrôleurs plus petits qui effectuent des actions telles que la réplication des pods et la gestion des opérations sur les nœuds.kube-controller-manager - The Controller Manager oversees a number of smaller Controllers that perform actions such as replicating pods and handling node operations.

AKS fournit un plan de contrôle monolocataire doté de dispositifs dédiés (serveur d’API, Scheduler, etc.). Vous définissez le nombre et la taille des nœuds, puis la plateforme Azure configure la communication sécurisée entre les nœuds et le plan de contrôle.AKS provides a single-tenant control plane, with a dedicated API server, Scheduler, etc. You define the number and size of the nodes, and the Azure platform configures the secure communication between the control plane and nodes. L’interaction avec le plan de contrôle se produit par le biais d’API Kubernetes, telles que kubectl ou le tableau de bord Kubernetes.Interaction with the control plane occurs through Kubernetes APIs, such as kubectl or the Kubernetes dashboard.

Ce plan de contrôle managé signifie que vous n’avez pas besoin de configurer de composants tels qu’un magasin etcd hautement disponible, mais aussi que vous ne pouvez pas accéder directement au plan de contrôle.This managed control plane means that you don't need to configure components like a highly available etcd store, but it also means that you can't access the control plane directly. Les mises à niveau de Kubernetes sont orchestrées par l’intermédiaire de l’interface de ligne de commande Azure ou du Portail Azure, qui met à niveau le plan de contrôle, puis les nœuds.Upgrades to Kubernetes are orchestrated through the Azure CLI or Azure portal, which upgrades the control plane and then the nodes. Pour résoudre les problèmes éventuels, vous pouvez consulter les journaux d’activité du plan de contrôle par le biais des journaux d’activité Azure Monitor.To troubleshoot possible issues, you can review the control plane logs through Azure Monitor logs.

Si vous devez configurer le plan de contrôle d’une façon particulière ou avez besoin d’un accès direct à ce dernier, vous pouvez déployer votre propre cluster Kubernetes à l’aide d’aks-engine.If you need to configure the control plane in a particular way or need direct access to it, you can deploy your own Kubernetes cluster using aks-engine.

Pour connaître les meilleures pratiques associées, consultez Meilleures pratiques relatives aux mises à jour et à la sécurité du cluster dans AKS.For associated best practices, see Best practices for cluster security and upgrades in AKS.

Nœuds et pools de nœudsNodes and node pools

Pour exécuter vos applications et les services de prise en charge, vous avez besoin d’un nœud Kubernetes.To run your applications and supporting services, you need a Kubernetes node. Un cluster AKS a un ou plusieurs nœuds, qui sont des machines virtuelles exécutant les composants des nœuds Kubernetes et le runtime de conteneur :An AKS cluster has one or more nodes, which is an Azure virtual machine (VM) that runs the Kubernetes node components and container runtime:

  • kubelet est l’agent Kubernetes qui traite les requêtes d’orchestration du plan de contrôle et la planification de l’exécution des conteneurs demandés.The kubelet is the Kubernetes agent that processes the orchestration requests from the control plane and scheduling of running the requested containers.
  • La mise en réseau virtuelle est gérée par le kube-proxy sur chaque nœud.Virtual networking is handled by the kube-proxy on each node. Le proxy route le trafic réseau et gère l’adressage IP pour les services et les pods.The proxy routes network traffic and manages IP addressing for services and pods.
  • Le runtime de conteneur est le composant qui permet aux applications en conteneur de s’exécuter et d’interagir avec d’autres ressources telles que le réseau virtuel et le stockage.The container runtime is the component that allows containerized applications to run and interact with additional resources such as the virtual network and storage. Dans AKS, Moby est utilisé en tant que runtime de conteneur.In AKS, Moby is used as the container runtime.

Ressources des machines virtuelles Azure et de prise en charge pour un nœud Kubernetes

La taille des machines virtuelles Azure pour vos nœuds détermine le nombre d’UC, la quantité de mémoire, ainsi que la taille et le type de stockage disponible (par exemple, SSD hautes performances ou HDD classique).The Azure VM size for your nodes defines how many CPUs, how much memory, and the size and type of storage available (such as high-performance SSD or regular HDD). Si vous pensez avoir un jour besoin d’applications nécessitant une grande quantité d’UC et de mémoire ou un stockage hautes performances, planifiez la taille des nœuds en conséquence.If you anticipate a need for applications that require large amounts of CPU and memory or high-performance storage, plan the node size accordingly. Vous pouvez également augmenter le nombre de nœuds dans votre cluster AKS afin de répondre à la demande.You can also scale out the number of nodes in your AKS cluster to meet demand.

Dans AKS, l’image de machine virtuelle pour les nœuds de votre cluster est actuellement basée sur Ubuntu Linux ou Windows Server 2019.In AKS, the VM image for the nodes in your cluster is currently based on Ubuntu Linux or Windows Server 2019. Quand vous créez un cluster AKS ou augmentez le nombre de nœuds, la plateforme Azure crée le nombre demandé de machines virtuelles et les configure.When you create an AKS cluster or scale out the number of nodes, the Azure platform creates the requested number of VMs and configures them. Vous n’avez aucune configuration manuelle à effectuer.There's no manual configuration for you to perform. Les nœuds agent étant facturés en tant que machines virtuelles standard, les remises dont vous bénéficiez sur la taille de machine virtuelle que vous utilisez (y compris les réservations Azure) sont automatiquement appliquées.Agent nodes are billed as standard virtual machines, so any discounts you have on the VM size you're using (including Azure reservations) are automatically applied.

Si vous avez besoin d’utiliser un autre système d’exploitation hôte ou runtime de conteneur, ou bien d’inclure des packages personnalisés, vous pouvez déployer votre propre cluster Kubernetes à l’aide d’aks-engine.If you need to use a different host OS, container runtime, or include custom packages, you can deploy your own Kubernetes cluster using aks-engine. En amont, aks-engine assure la mise en production des fonctionnalités et fournit les options de configuration avant qu'elles ne soient officiellement prises en charge dans les clusters AKS.The upstream aks-engine releases features and provides configuration options before they are officially supported in AKS clusters. Par exemple, si vous souhaitez utiliser un runtime de conteneur autre que Moby, vous pouvez utiliser aks-engine pour configurer et déployer un cluster Kubernetes qui répond à vos besoins actuels.For example, if you wish to use a container runtime other than Moby, you can use aks-engine to configure and deploy a Kubernetes cluster that meets your current needs.

Réservations de ressourcesResource reservations

Les ressources de nœud sont utilisées par AKS pour faire fonctionner le nœud dans le cadre de votre cluster.Node resources are utilized by AKS to make the node function as part of your cluster. Cela peut créer un écart entre les ressources totales de votre nœud et les ressources allouables quand elles sont utilisées dans AKS.This can create a discrepancy between your node's total resources and the resources allocatable when used in AKS. Il est important de le noter lors de la définition de demandes et de limites pour les pods déployés par l’utilisateur.This is important to note when setting requests and limits for user deployed pods.

Pour rechercher les ressources allouables d’un nœud, exécutez :To find a node's allocatable resources run:

kubectl describe node [NODE_NAME]

Pour conserver les fonctionnalités et les performances des nœuds, les ressources sont réservées sur chaque nœud par AKS.To maintain node performance and functionality, resources are reserved on each node by AKS. Dans la mesure où un nœud gagne en taille dans les ressources, la réservation de ressources augmente en raison d’une plus grande quantité de pods déployés par l’utilisateur nécessitant une gestion.As a node grows larger in resources, the resource reservation grows due to a higher amount of user deployed pods needing management.

Notes

L’utilisation de modules complémentaires AKS tels que Container Insights (OMS) nécessite des ressources de nœud supplémentaires.Using AKS add-ons such as Container Insights (OMS) will consume additional node resources.

  • Processeur : le processeur réservé dépend du type de nœud et de la configuration du cluster, ce qui peut aboutir à un processeur moins allouable en raison de l’exécution de fonctionnalités supplémentairesCPU - reserved CPU is dependent on node type and cluster configuration which may cause less allocatable CPU due to running additional features
Cœurs de processeur sur l’hôteCPU cores on host 11 22 44 88 1616 3232 6464
Réservés par Kube (millicores)Kube-reserved (millicores) 6060 100100 140140 180180 260260 420420 740740
  • Mémoire – la mémoire utilisée par AKS comprend la somme de deux valeurs.Memory - memory utilized by AKS includes the sum of two values.
  1. Le démon kubelet est installé sur tous les nœuds de l’agent Kubernetes pour gérer la création et l’arrêt du conteneur.The kubelet daemon is installed on all Kubernetes agent nodes to manage container creation and termination. Par défaut sur AKS, ce démon a la règle d’éviction suivante : memory.available<750Mi, ce qui signifie qu’un nœud doit toujours avoir au moins 750 Mi allouable à tout moment.By default on AKS, this daemon has the following eviction rule: memory.available<750Mi, which means a node must always have at least 750 Mi allocatable at all times. Lorsqu’un hôte se trouve au-dessous de ce seuil de mémoire disponible, kubelet met fin à l’un des pods en cours d’exécution pour libérer de la mémoire sur l’ordinateur hôte et le protéger.When a host is below that threshold of available memory, the kubelet will terminate one of the running pods to free memory on the host machine and protect it. Il s’agit d’une action réactive lorsque la mémoire disponible diminue au-delà du seuil 750Mi.This is a reactive action once available memory decreases beyond the 750Mi threshold.

  2. La deuxième valeur est une vitesse régressive des réservations de la mémoire pour que le démon kubelet fonctionne correctement (kube-reserved).The second value is a regressive rate of memory reservations for the kubelet daemon to properly function (kube-reserved).

    • 25 % des 4 premiers Go de mémoire25% of the first 4 GB of memory
    • 20 % des 4 Go suivants de mémoire (jusqu’à 8 Go)20% of the next 4 GB of memory (up to 8 GB)
    • 10 % des 8 Go suivants de mémoire (jusqu’à 16 Go)10% of the next 8 GB of memory (up to 16 GB)
    • 6 % des 112 Go suivants de mémoire (jusqu’à 128 Go)6% of the next 112 GB of memory (up to 128 GB)
    • 2 % de la mémoire au-dessus de 128 Go2% of any memory above 128 GB

Les règles ci-dessus relatives à l’allocation de mémoire et d’UC sont utilisées pour assurer l’intégrité des nœuds de l’agent, dont certains pods de système d’hébergement critiques pour l’intégrité du cluster.The above rules for memory and CPU allocation are used to keep agent nodes healthy, including some hosting system pods that are critical to cluster health. Ces règles d’allocation font également en sorte que le nœud signale moins de mémoire allouée et d’UC qu’il ne le ferait s’il faisait partie d’un cluster Kubernetes.These allocation rules also cause the node to report less allocatable memory and CPU than it would if it were not part of a Kubernetes cluster. Vous ne pouvez pas changer les réservations de ressources ci-dessus.The above resource reservations can't be changed.

Par exemple, si un nœud offre 7 Go, il signalera 34 % de la mémoire non allouable en plus du seuil d’éviction dur de 750Mi.For example, if a node offers 7 GB, it will report 34% of memory not allocatable on top of the 750Mi hard eviction threshold.

(0.25*4) + (0.20*3) = + 1 GB + 0.6GB = 1.6GB / 7GB = 22.86% reserved

En plus des réservations pour Kubernetes lui-même, le système d’exploitation du nœud sous-jacent réserve également une quantité de ressources de processeur et de mémoire pour gérer les fonctions du système d’exploitation.In addition to reservations for Kubernetes itself, the underlying node OS also reserves an amount of CPU and memory resources to maintain OS functions.

Pour connaître les meilleures pratiques associées, consultez la section Meilleures pratiques relatives aux fonctionnalités de base du planificateur dans AKS.For associated best practices, see Best practices for basic scheduler features in AKS.

Pools de nœudsNode pools

Les nœuds d’une même configuration sont regroupés dans des pools de nœuds.Nodes of the same configuration are grouped together into node pools. Un cluster Kubernetes contient un ou plusieurs pools de nœuds.A Kubernetes cluster contains one or more node pools. Le nombre et la taille initiaux des nœuds sont définis quand vous créez un cluster AKS, opération qui engendre la création d’un nœud de pools par défaut.The initial number of nodes and size are defined when you create an AKS cluster, which creates a default node pool. Ce pool de nœuds par défaut dans AKS contient les machines virtuelles sous-jacentes qui exécutent vos nœuds d’agent.This default node pool in AKS contains the underlying VMs that run your agent nodes.

Notes

Pour garantir un fonctionnement fiable de votre cluster, vous devez exécuter au moins 2 (deux) nœuds dans le pool de nœuds par défaut.To ensure your cluster operates reliably, you should run at least 2 (two) nodes in the default node pool.

Quand vous mettez à l’échelle ou à niveau un cluster AKS, l’action est effectuée sur le pool de nœuds par défaut.When you scale or upgrade an AKS cluster, the action is performed against the default node pool. Vous pouvez aussi choisir de mettre à l’échelle ou de mettre à niveau un pool de nœuds spécifique.You can also choose to scale or upgrade a specific node pool. Pour les opérations de mise à niveau, les conteneurs en cours d’exécution sont planifiés sur d’autres nœuds du pool de nœuds jusqu’à ce que tous les nœuds soient mis à niveau.For upgrade operations, running containers are scheduled on other nodes in the node pool until all the nodes are successfully upgraded.

Pour en savoir plus sur l’utilisation de plusieurs pools de nœuds dans AKS, voir Créer et gérer plusieurs pools de nœuds pour un cluster dans AKS.For more information about how to use multiple node pools in AKS, see Create and manage multiple node pools for a cluster in AKS.

Sélecteurs de nœudNode selectors

Dans un cluster AKS qui contient plusieurs pools de nœuds, vous devrez peut-être indiquer au planificateur Kubernetes Scheduler le pool de nœuds qui devra être utilisé pour une ressource donnée.In an AKS cluster that contains multiple node pools, you may need to tell the Kubernetes Scheduler which node pool to use for a given resource. Par exemple, les contrôleurs d’entrée ne doivent pas s’exécuter sur des nœuds Windows Server.For example, ingress controllers shouldn't run on Windows Server nodes. Les sélecteurs de nœud vous permettent de définir différents paramètres, comme le système d’exploitation des nœuds, pour contrôler à quel endroit un pod doit être planifié.Node selectors let you define various parameters, such as the node OS, to control where a pod should be scheduled.

L’exemple de base suivant planifie une instance NGINX sur un nœud Linux en utilisant le sélecteur de nœud "beta.kubernetes.io/os": linux :The following basic example schedules an NGINX instance on a Linux node using the node selector "beta.kubernetes.io/os": linux:

kind: Pod
apiVersion: v1
metadata:
  name: nginx
spec:
  containers:
    - name: myfrontend
      image: nginx:1.15.12
  nodeSelector:
    "beta.kubernetes.io/os": linux

Pour plus d’informations sur la façon de contrôler l’endroit où sont planifiés les pods, consultez la section Meilleures pratiques relatives aux fonctionnalités avancées du planificateur dans AKS.For more information on how to control where pods are scheduled, see Best practices for advanced scheduler features in AKS.

PodsPods

Kubernetes Utilise des pods pour exécuter une instance de votre application.Kubernetes uses pods to run an instance of your application. Un pod représente une instance unique de votre application.A pod represents a single instance of your application. Les pods ont généralement un mappage 1 à 1 avec un conteneur, bien qu’il existe des scénarios avancés où un pod peut contenir plusieurs conteneurs.Pods typically have a 1:1 mapping with a container, although there are advanced scenarios where a pod may contain multiple containers. Ces pods multiconteneurs sont planifiés ensemble sur le même nœud et permettent aux conteneurs de partager des ressources connexes.These multi-container pods are scheduled together on the same node, and allow containers to share related resources.

Quand vous créez un pod, vous pouvez définir des demandes de ressources afin de demander une certaine quantité de ressources de processeur ou de mémoire.When you create a pod, you can define resource requests to request a certain amount of CPU or memory resources. Le planificateur de Kubernetes essaie de planifier les pods afin qu’ils s’exécutent sur un nœud dont les ressources permettent de répondre à la demande.The Kubernetes Scheduler tries to schedule the pods to run on a node with available resources to meet the request. Vous pouvez également spécifier des limites de ressources maximales qui empêchent un pod donné de consommer trop de ressources de calcul à partir du nœud sous-jacent.You can also specify maximum resource limits that prevent a given pod from consuming too much compute resource from the underlying node. Une bonne pratique consiste à inclure des limites de ressources pour tous les pods afin d'aider le Scheduler Kubernetes à identifier les ressources nécessaires et autorisées.A best practice is to include resource limits for all pods to help the Kubernetes Scheduler understand which resources are needed and permitted.

Pour plus d’informations, consultez Kubernetes pods (Pods Kubernetes) et Kubernetes pod lifecycle (Cycle de vie des pods Kubernetes).For more information, see Kubernetes pods and Kubernetes pod lifecycle.

Un pod est une ressource logique, tandis que les conteneurs sont l’endroit où s’exécutent les charges de travail d’applications.A pod is a logical resource, but the container(s) are where the application workloads run. Les pods sont en général des ressources éphémères jetables, et ceux planifiés individuellement ne bénéficient pas de toutes les fonctionnalités de haute disponibilité et de redondance fournies par Kubernetes.Pods are typically ephemeral, disposable resources, and individually scheduled pods miss some of the high availability and redundancy features Kubernetes provides. Au lieu de cela, les pods sont généralement déployés et gérés par des contrôleurs Kubernetes, tels que le contrôleur de déploiement.Instead, pods are usually deployed and managed by Kubernetes Controllers, such as the Deployment Controller.

Déploiements et manifestes YAMLDeployments and YAML manifests

Un déploiement représente un ou plusieurs pods identiques, gérés par le contrôleur de déploiement Kubernetes.A deployment represents one or more identical pods, managed by the Kubernetes Deployment Controller. Un déploiement définit le nombre de réplicas (pods) à créer, tandis que le planificateur de Kubernetes veille à ce que des pods supplémentaires soient planifiés sur des nœuds sains si les pods ou les nœuds rencontrent des problèmes.A deployment defines the number of replicas (pods) to create, and the Kubernetes Scheduler ensures that if pods or nodes encounter problems, additional pods are scheduled on healthy nodes.

Vous pouvez mettre à jour les déploiements pour changer la configuration des pods, l’image de conteneur utilisée ou le stockage attaché.You can update deployments to change the configuration of pods, container image used, or attached storage. Le contrôleur de déploiement draine et met fin à un certain nombre de réplicas, crée des réplicas à partir de la nouvelle définition de déploiement et poursuit le processus jusqu’à ce que tous les réplicas dans le déploiement soient mis à jour.The Deployment Controller drains and terminates a given number of replicas, creates replicas from the new deployment definition, and continues the process until all replicas in the deployment are updated.

La plupart des applications sans état dans AKS doivent utiliser le modèle de déploiement plutôt que la planification de pods individuels.Most stateless applications in AKS should use the deployment model rather than scheduling individual pods. Kubernetes peut superviser l’intégrité et l’état des déploiements pour s’assurer que le nombre requis de réplicas s’exécutent dans le cluster.Kubernetes can monitor the health and status of deployments to ensure that the required number of replicas run within the cluster. Quand vous planifiez uniquement des pods individuels, ces derniers ne sont pas redémarrés s’ils rencontrent un problème et ne sont pas replanifiés sur des nœuds sains si leur nœud actuel rencontre un problème.When you only schedule individual pods, the pods aren't restarted if they encounter a problem, and aren't rescheduled on healthy nodes if their current node encounters a problem.

Si une application requiert qu’un quorum d’instances soit toujours disponible pour les prises de décisions de gestion, il convient qu’aucun processus de mise à jour ne rompe ce dispositif.If an application requires a quorum of instances to always be available for management decisions to be made, you don't want an update process to disrupt that ability. Vous pouvez utiliser des budgets d’interruption de pods pour définir le nombre de réplicas dans un déploiement pouvant être retirés pendant une mise à niveau d’un nœud ou une mise à jour.Pod Disruption Budgets can be used to define how many replicas in a deployment can be taken down during an update or node upgrade. Par exemple, si votre déploiement comprend 5 réplicas, vous pouvez définir une interruption de pods de 4 pour autoriser la suppression ou la replanification d’un seul réplica à la fois.For example, if you have 5 replicas in your deployment, you can define a pod disruption of 4 to only permit one replica from being deleted/rescheduled at a time. Comme dans le cas des limites de ressources des pods, une bonne pratique consiste à définir des budgets d’interruption de pods sur les applications qui nécessitent la présence systématique d’un nombre minimal de réplicas.As with pod resource limits, a best practice is to define pod disruption budgets on applications that require a minimum number of replicas to always be present.

Les déploiements sont généralement créés et gérés avec kubectl create ou kubectl apply.Deployments are typically created and managed with kubectl create or kubectl apply. Pour créer un déploiement, vous définissez un fichier manifeste dans le format YAML (YAML Ain't Markup Language).To create a deployment, you define a manifest file in the YAML (YAML Ain't Markup Language) format. L’exemple suivant crée un déploiement de base du serveur web NGINX.The following example creates a basic deployment of the NGINX web server. Le déploiement spécifie la création de 3 réplicas et l’ouverture du port 80 sur le conteneur.The deployment specifies 3 replicas to be created, and that port 80 be open on the container. Des demandes et limites de ressources sont également définies pour l’UC et la mémoire.Resource requests and limits are also defined for CPU and memory.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.15.2
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: 250m
            memory: 64Mi
          limits:
            cpu: 500m
            memory: 256Mi

Vous pouvez également créer des applications plus complexes en incluant des services tels que des équilibreurs de charge dans le manifeste YAML.More complex applications can be created by also including services such as load balancers within the YAML manifest.

Pour plus d’informations, consultez la section Déploiements Kubernetes.For more information, see Kubernetes deployments.

Gestion des packages avec HelmPackage management with Helm

Dans Kubernetes, la gestion des applications fait souvent appel à Helm.A common approach to managing applications in Kubernetes is with Helm. Vous pouvez créer et utiliser des graphiques Helm publics existants qui contiennent une version empaquetée d’un code d’application et de manifestes YAML Kubernetes pour le déploiement de ressources.You can build and use existing public Helm charts that contain a packaged version of application code and Kubernetes YAML manifests to deploy resources. Ces graphiques Helm peuvent être stockés localement, ou souvent dans un référentiel distant, tel qu’un référentiel de graphiques Helm Azure Container Registry.These Helm charts can be stored locally, or often in a remote repository, such as an Azure Container Registry Helm chart repo.

Pour que vous puissiez utiliser Helm, un composant de serveur appelé Tiller est installé dans votre cluster Kubernetes.To use Helm, a server component called Tiller is installed in your Kubernetes cluster. Le composant Tiller gère l’installation des graphiques au sein du cluster.The Tiller manages the installation of charts within the cluster. Le client Helm est lui-même installé localement sur votre ordinateur, ou peut être utilisé dans Azure Cloud Shell.The Helm client itself is installed locally on your computer, or can be used within the Azure Cloud Shell. Vous pouvez rechercher ou créer des graphiques Helm avec le client, puis les installer sur votre cluster Kubernetes.You can search for or create Helm charts with the client, and then install them to your Kubernetes cluster.

Helm comprend un composant client et un composant Tiller côté serveur qui crée des ressources à l’intérieur du cluster Kubernetes

Pour plus d’informations, consultez la section Installer des applications avec Helm dans AKS (Azure Kubernetes Service).For more information, see Install applications with Helm in Azure Kubernetes Service (AKS).

Ressources StatefulSet et ressources DaemonSetStatefulSets and DaemonSets

Le contrôleur de déploiement utilise le planificateur de Kubernetes pour exécuter un certain nombre de réplicas sur n’importe quel nœud disponible ayant des ressources.The Deployment Controller uses the Kubernetes Scheduler to run a given number of replicas on any available node with available resources. Cette approche de l’utilisation des déploiements peut être suffisante pour les applications sans état, mais pas pour les applications qui nécessitent un stockage ou une convention de nommage persistant.This approach of using deployments may be sufficient for stateless applications, but not for applications that require a persistent naming convention or storage. Pour les applications qui nécessitent qu’un réplica existe sur chaque nœud, ou certains nœuds, au sein d’un cluster, le contrôleur de déploiement ne considère pas la façon dont les réplicas sont répartis entre les nœuds.For applications that require a replica to exist on each node, or selected nodes, within a cluster, the Deployment Controller doesn't look at how replicas are distributed across the nodes.

Il existe deux ressources Kubernetes qui vous permettent de gérer ces types d’applications :There are two Kubernetes resources that let you manage these types of applications:

  • Ressources StatefulSet : maintiennent l’état des applications au-delà du cycle de vie d’un pod individuel, tel que le stockage.StatefulSets - Maintain the state of applications beyond an individual pod lifecycle, such as storage.
  • Ressources DaemonSet : garantissent une instance en cours d’exécution sur chaque nœud, tôt dans le processus de démarrage de Kubernetes.DaemonSets - Ensure a running instance on each node, early in the Kubernetes bootstrap process.

Ressources StatefulSetStatefulSets

Le développement d’applications modernes s’adresse souvent aux applications sans état, mais vous pouvez utiliser des ressources StatefulSet pour les applications avec état, telles que les applications qui incluent des composants de base de données.Modern application development often aims for stateless applications, but StatefulSets can be used for stateful applications, such as applications that include database components. Une ressource StatefulSet est similaire à un déploiement, car un ou plusieurs pods identiques sont créés et gérés.A StatefulSet is similar to a deployment in that one or more identical pods are created and managed. Les réplicas d’une ressource StatefulSet suivent une approche séquentielle et sans perte de données du déploiement, de la mise à l’échelle, des mises à niveau et des arrêts.Replicas in a StatefulSet follow a graceful, sequential approach to deployment, scale, upgrades, and terminations. Avec une ressource StatefulSet (quand les réplicas sont replanifiés), la convention d’affectation de noms, les noms de réseau et le stockage persistent.With a StatefulSet (as replicas are rescheduled) the naming convention, network names, and storage persist.

Vous définissez l’application au format YAML en utilisant kind: StatefulSet, puis le contrôleur StatefulSet gère le déploiement et la gestion des réplicas requis.You define the application in YAML format using kind: StatefulSet, and the StatefulSet Controller then handles the deployment and management of the required replicas. Les données sont écrites dans un stockage persistant, fourni par Azure Disques managés ou Azure Files.Data is written to persistent storage, provided by Azure Managed Disks or Azure Files. Avec une ressource StatefulSet, le stockage permanent sous-jacent demeure, même quand la ressource est supprimée.With StatefulSets, the underlying persistent storage remains even when the StatefulSet is deleted.

Pour plus d’informations, consultez la section Kubernetes StatefulSets.For more information, see Kubernetes StatefulSets.

Les réplicas dans une ressource StatefulSet sont planifiés et exécutés sur n’importe quel nœud disponible dans un cluster AKS.Replicas in a StatefulSet are scheduled and run across any available node in an AKS cluster. Si vous devez vous assurer qu’au moins un pod dans votre jeu s’exécute sur un nœud, vous pouvez utiliser à la place une ressource DaemonSet.If you need to ensure that at least one pod in your Set runs on a node, you can instead use a DaemonSet.

Ressources DaemonSetDaemonSets

Dans le cadre d’une supervision ou d’une collecte de journaux spécifique, vous pouvez être amené à exécuter un pod donné sur la totalité ou une partie des nœuds.For specific log collection or monitoring needs, you may need to run a given pod on all, or selected, nodes. Une ressource DaemonSet permet de déployer un ou plusieurs pods identiques, mais le contrôleur DaemonSet garantit que chaque nœud spécifié exécute une instance du pod.A DaemonSet is again used to deploy one or more identical pods, but the DaemonSet Controller ensures that each node specified runs an instance of the pod.

Le contrôleur DaemonSet peut planifier des pods sur des nœuds tôt dans le processus de démarrage du cluster, avant que ne démarre le planificateur Kubernetes par défaut.The DaemonSet Controller can schedule pods on nodes early in the cluster boot process, before the default Kubernetes scheduler has started. Ainsi, les pods dans une ressource DaemonSet sont démarrés avant que ne soient planifiés les pods traditionnels dans un déploiement ou une ressource StatefulSet.This ability ensures that the pods in a DaemonSet are started before traditional pods in a Deployment or StatefulSet are scheduled.

À l’image des ressources StatefulSet, une ressource DaemonSet est définie dans le cadre d’une définition YAML à l’aide de kind: DaemonSet.Like StatefulSets, a DaemonSet is defined as part of a YAML definition using kind: DaemonSet.

Pour plus d’informations, consultez la section Kubernetes DaemonSets.For more information, see Kubernetes DaemonSets.

Notes

Si vous utilisez le complément add-on Virtual Nodes, les DaemonSets ne créeront pas de pods sur le nœud virtuel.If using the Virtual Nodes add-on, DaemonSets will not create pods on the virtual node.

Espaces de nomsNamespaces

Les ressources Kubernetes, telles que les pods et les déploiements, sont regroupées logiquement dans un espace de noms.Kubernetes resources, such as pods and Deployments, are logically grouped into a namespace. Ces regroupements permettent de scinder un cluster AKS logiquement et de restreindre l’accès pour la création, l’affichage ou la gestion des ressources.These groupings provide a way to logically divide an AKS cluster and restrict access to create, view, or manage resources. Vous pouvez créer des espaces de noms pour séparer les groupes métier, par exemple.You can create namespaces to separate business groups, for example. Les utilisateurs ne peuvent interagir qu’avec les ressources appartenant aux espaces de noms qui leur sont attribués.Users can only interact with resources within their assigned namespaces.

Espaces de noms Kubernetes pour séparer logiquement les ressources et les applications

Quand vous créez un cluster AKS, les espaces de noms suivants sont disponibles :When you create an AKS cluster, the following namespaces are available:

  • default : espace de noms dans lequel sont créés par défaut les pods et les déploiements quand aucun espace de noms n’est fourni.default - This namespace is where pods and deployments are created by default when none is provided. Dans les environnements plus petits, vous pouvez déployer les applications directement dans l’espace de noms par défaut sans provoquer la création de séparations logiques supplémentaires.In smaller environments, you can deploy applications directly into the default namespace without creating additional logical separations. Quand vous interagissez avec l’API Kubernetes, comme avec kubectl get pods, l’espace de noms par défaut est utilisé si aucun n’est spécifié.When you interact with the Kubernetes API, such as with kubectl get pods, the default namespace is used when none is specified.
  • kube-system : espace de noms où se trouvent les principales ressources, telles que les fonctionnalités réseau, comme le DNS et le proxy, ou bien le tableau de bord Kubernetes.kube-system - This namespace is where core resources exist, such as network features like DNS and proxy, or the Kubernetes dashboard. En règle générale, vous ne déployez pas vos propres applications dans cet espace de noms.You typically don't deploy your own applications into this namespace.
  • kube-public : cet espace de noms n'est généralement pas utilisé, mais vous pouvez y recourir pour rendre les ressources visibles dans l'ensemble du cluster et consultables par tous les utilisateurs.kube-public - This namespace is typically not used, but can be used for resources to be visible across the whole cluster, and can be viewed by any user.

Pour plus d’informations, consultez la section Espace de noms Kubernetes.For more information, see Kubernetes namespaces.

Étapes suivantesNext steps

Cet article décrit certains des principaux composants Kubernetes et leur application aux clusters AKS.This article covers some of the core Kubernetes components and how they apply to AKS clusters. Pour plus d’informations sur les concepts fondamentaux de Kubernetes et d’AKS, consultez les articles suivants :For additional information on core Kubernetes and AKS concepts, see the following articles: