Kubernetes Core-koncept för Azure Kubernetes service (AKS)Kubernetes core concepts for Azure Kubernetes Service (AKS)

När program utvecklingen flyttas till en container-baserad metod är behovet av att dirigera och hantera resurser viktigt.As application development moves towards a container-based approach, the need to orchestrate and manage resources is important. Kubernetes är den ledande plattformen som ger möjlighet att tillhandahålla tillförlitlig schemaläggning av feltoleranta program arbets belastningar.Kubernetes is the leading platform that provides the ability to provide reliable scheduling of fault-tolerant application workloads. Azure Kubernetes service (AKS) är ett hanterat Kubernetes-erbjudande som ytterligare fören klar distribution och hantering av container-baserade program.Azure Kubernetes Service (AKS) is a managed Kubernetes offering that further simplifies container-based application deployment and management.

Den här artikeln beskriver kärn Kubernetes infrastruktur komponenter som kontroll plan , noder och nodkonfigurationer .This article introduces the core Kubernetes infrastructure components such as the control plane , nodes , and node pools . Arbets belastnings resurser som poddar , distributioner och uppsättningar introduceras också, tillsammans med hur du grupperar resurser till namn områden .Workload resources such as pods , deployments , and sets are also introduced, along with how to group resources into namespaces .

Vad är Kubernetes?What is Kubernetes?

Kubernetes är en snabbt växande plattform som hanterar containerbaserade program och deras associerade nätverks-och lagrings komponenter.Kubernetes is a rapidly evolving platform that manages container-based applications and their associated networking and storage components. Fokus är på program arbets belastningarna, inte de underliggande infrastruktur komponenterna.The focus is on the application workloads, not the underlying infrastructure components. Kubernetes innehåller en deklarativ metod för distributioner, som backas upp av en robust uppsättning API: er för hanterings åtgärder.Kubernetes provides a declarative approach to deployments, backed by a robust set of APIs for management operations.

Du kan skapa och köra moderna, bärbara och mikrotjänster-baserade program som drar nytta av Kubernetes-dirigering och hantering av tillgängligheten för dessa program komponenter.You can build and run modern, portable, microservices-based applications that benefit from Kubernetes orchestrating and managing the availability of those application components. Kubernetes har stöd för både tillstånds lösa och tillstånds känsliga program som lag förloppet genom att använda mikrotjänster-baserade program.Kubernetes supports both stateless and stateful applications as teams progress through the adoption of microservices-based applications.

Som en öppen plattform kan du med Kubernetes skapa dina program med önskat programmeringsspråk, OS, bibliotek eller meddelande buss.As an open platform, Kubernetes allows you to build your applications with your preferred programming language, OS, libraries, or messaging bus. Befintliga verktyg för kontinuerlig integrering och verktyg för kontinuerlig leverans (CI/CD) kan integreras med Kubernetes för att schemalägga och distribuera versioner.Existing continuous integration and continuous delivery (CI/CD) tools can integrate with Kubernetes to schedule and deploy releases.

Azure Kubernetes service (AKS) tillhandahåller en hanterad Kubernetes-tjänst som minskar komplexiteten för distributions-och kärn hanterings aktiviteter, inklusive samordning av uppgraderingar.Azure Kubernetes Service (AKS) provides a managed Kubernetes service that reduces the complexity for deployment and core management tasks, including coordinating upgrades. AKS-kontroll planet hanteras av Azure-plattformen och du betalar bara för de AKS-noder som kör dina program.The AKS control plane is managed by the Azure platform, and you only pay for the AKS nodes that run your applications. AKS bygger påAKS-motornmed öppen källkod i Azure Kubernetes.AKS is built on top of the open-source Azure Kubernetes Service Engine (aks-engine).

Arkitektur för Kubernetes-klusterKubernetes cluster architecture

Ett Kubernetes-kluster är uppdelat i två komponenter:A Kubernetes cluster is divided into two components:

  • Control plan -noder tillhandahåller de viktigaste Kubernetes-tjänsterna och dirigeringen av program arbets belastningar.Control plane nodes provide the core Kubernetes services and orchestration of application workloads.
  • Noderna kör dina program arbets belastningar.Nodes run your application workloads.

Kubernetes kontroll plan och nod komponenter

KontrollplanControl plane

När du skapar ett AKS-kluster skapas och konfigureras ett kontroll plan automatiskt.When you create an AKS cluster, a control plane is automatically created and configured. Det här kontroll planet tillhandahålls som en hanterad Azure-resurs som är abstrakt från användaren.This control plane is provided as a managed Azure resource abstracted from the user. Det finns ingen kostnad för kontroll planet, bara de noder som ingår i AKS-klustret.There's no cost for the control plane, only the nodes that are part of the AKS cluster. Kontroll planet och dess resurser finns bara i den region där du skapade klustret.The control plane and its resources reside only on the region where you created the cluster.

Kontroll planet innehåller följande kärn Kubernetes-komponenter:The control plane includes the following core Kubernetes components:

  • Kube-apiserver – API-servern är hur de underliggande Kubernetes-API: erna exponeras.kube-apiserver - The API server is how the underlying Kubernetes APIs are exposed. Den här komponenten ger interaktion för hanterings verktyg, till exempel kubectl eller Kubernetes-instrumentpanelen.This component provides the interaction for management tools, such as kubectl or the Kubernetes dashboard.
  • etcd – för att underhålla status för ditt Kubernetes-kluster och-konfiguration är hög tillgänglig etcd ett nyckel värdes lager inom 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 – när du skapar eller skalar program bestämmer Scheduler vilka noder som kan köra arbets belastningen och startar dem.kube-scheduler - When you create or scale applications, the Scheduler determines what nodes can run the workload and starts them.
  • Kube-Controller-Manager – Controller Manager ser över ett antal mindre styrenheter som utför åtgärder som att replikera poddar och hantera Node-åtgärder.kube-controller-manager - The Controller Manager oversees a number of smaller Controllers that perform actions such as replicating pods and handling node operations.

AKS tillhandahåller ett kontroll plan för en enskild klient, med en dedikerad API-Server, Scheduler, osv. Du definierar antalet och storleken på noderna, och Azure-plattformen konfigurerar den säkra kommunikationen mellan kontroll planet och noderna.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. Interaktion med kontroll planet sker via Kubernetes-API: er, till exempel kubectl eller Kubernetes-instrumentpanelen.Interaction with the control plane occurs through Kubernetes APIs, such as kubectl or the Kubernetes dashboard.

Detta hanterade kontroll plan innebär att du inte behöver konfigurera komponenter som en hög tillgänglig etcd -butik, men det innebär också att du inte kan komma åt kontroll planet direkt.This managed control plane means you don't need to configure components like a highly available etcd store, but it also means you can't access the control plane directly. Uppgraderingar av Kubernetes dirigeras via Azure CLI eller Azure Portal, som uppgraderar kontroll planet och noderna.Upgrades to Kubernetes are orchestrated through the Azure CLI or Azure portal, which upgrades the control plane and then the nodes. Om du vill felsöka eventuella problem kan du granska kontroll Plans loggarna via Azure Monitor loggar.To troubleshoot possible issues, you can review the control plane logs through Azure Monitor logs.

Om du behöver konfigurera kontroll planet på ett visst sätt eller behöver direkt åtkomst till det kan du distribuera ditt eget Kubernetes-kluster med 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.

För associerade metod tips, se metod tips för kluster säkerhet och uppgraderingar i AKS.For associated best practices, see Best practices for cluster security and upgrades in AKS.

Noder och Node-poolerNodes and node pools

Om du vill köra program och stöd tjänster behöver du en Kubernetes- nod .To run your applications and supporting services, you need a Kubernetes node . Ett AKS-kluster har en eller flera noder, som är en virtuell Azure-dator (VM) som kör Kubernetes-nodens komponenter och behållar körningen: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Är Kubernetes-agenten som bearbetar Orchestration-begärandena från kontroll planet och schemaläggning av att köra de begärda behållarna.The kubelet is the Kubernetes agent that processes the orchestration requests from the control plane and scheduling of running the requested containers.
  • Virtuella nätverk hanteras av Kube-proxy på varje nod.Virtual networking is handled by the kube-proxy on each node. Proxyservern dirigerar nätverks trafik och hanterar IP-adresser för tjänster och poddar.The proxy routes network traffic and manages IP addressing for services and pods.
  • Container runtime är den komponent som gör det möjligt för program i behållare att köra och interagera med ytterligare resurser, till exempel det virtuella nätverket och lagringen.The container runtime is the component that allows containerized applications to run and interact with additional resources such as the virtual network and storage. I AKS används Moby som container Runtime.In AKS, Moby is used as the container runtime.

Virtuell Azure-dator och stöd resurser för en Kubernetes-nod

Storleken på virtuella Azure-datorer för dina noder definierar hur många processorer, hur mycket minne och storlek och typ av lagring som är tillgängliga (till exempel SSD eller vanlig hård disk med höga prestanda).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). Om du förväntar dig ett behov av program som kräver stora mängder CPU-och minnes-eller lagrings utrymme för hög prestanda bör du planera storleken på noderna.If you anticipate a need for applications that require large amounts of CPU and memory or high-performance storage, plan the node size accordingly. Du kan också skala ut antalet noder i ditt AKS-kluster för att möta efter frågan.You can also scale out the number of nodes in your AKS cluster to meet demand.

I AKS baseras den virtuella dator avbildningen för noderna i klustret för närvarande på Ubuntu Linux eller Windows Server 2019.In AKS, the VM image for the nodes in your cluster is currently based on Ubuntu Linux or Windows Server 2019. När du skapar ett AKS-kluster eller skalar ut antalet noder, skapar Azure-plattformen det begärda antalet virtuella datorer och konfigurerar dem.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. Det finns ingen manuell konfiguration som du kan utföra.There's no manual configuration for you to perform. Agent-noder faktureras som standard virtuella datorer så att eventuella rabatter som du har på den virtuella dator storleken som du använder (inklusive Azure-reservationer) används automatiskt.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.

Om du behöver använda ett annat värd operativ system, container runtime eller inkludera anpassade paket kan du distribuera ditt eget Kubernetes-kluster med 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. De överordnade versions aks-engine funktionerna och innehåller konfigurations alternativ innan de stöds officiellt i AKS-kluster.The upstream aks-engine releases features and provides configuration options before they are officially supported in AKS clusters. Om du till exempel vill använda en annan behållar körning än Moby kan du använda aks-engine för att konfigurera och distribuera ett Kubernetes-kluster som uppfyller dina aktuella behov.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.

Resurs reservationerResource reservations

Node-resurser används av AKS för att göra Node-funktionen som en del av klustret.Node resources are utilized by AKS to make the node function as part of your cluster. Den här användningen kan skapa en avvikelse mellan nodens totala resurser och de resurser som allocatable när de används i AKS.This usage can create a discrepancy between your node's total resources and the resources allocatable when used in AKS. Den här informationen är viktig för att notera när du ställer in förfrågningar och begränsningar för användare som har distribuerat poddar.This information is important to note when setting requests and limits for user deployed pods.

Om du vill hitta en nods allocatable-resurser kör du:To find a node's allocatable resources, run:

kubectl describe node [NODE_NAME]

För att upprätthålla prestanda och funktioner för noden reserveras resurser på varje nod av AKS.To maintain node performance and functionality, resources are reserved on each node by AKS. När en nod växer större i resurser växer resurs reservationen på grund av en högre mängd användar distribuerade poddar som behöver hanteras.As a node grows larger in resources, the resource reservation grows due to a higher amount of user deployed pods needing management.

Anteckning

Användning av AKS-tillägg som container Insights (OMS) kommer att använda ytterligare resurs resurser.Using AKS add-ons such as Container Insights (OMS) will consume additional node resources.

  • CPU -reserverad CPU är beroende av nodtypen och kluster konfigurationen, vilket kan orsaka mindre allocatable CPU på grund av att ytterligare funktioner körsCPU - reserved CPU is dependent on node type and cluster configuration, which may cause less allocatable CPU due to running additional features
PROCESSOR kärnor på värdCPU cores on host 11 22 44 88 1616 3232 6464
Kube-reserverade (millicores)Kube-reserved (millicores) 6060 100100 140140 180180 260260 420420 740740
  • Minnes minne som används av AKS inkluderar summan av två värden.Memory - memory utilized by AKS includes the sum of two values.
  1. Daemon för kubelet har installerats på alla Kubernetes-agent-noder för att hantera skapande och avslutning av behållare.The kubelet daemon is installed on all Kubernetes agent nodes to manage container creation and termination. Som standard har daemonen följande borttagnings regel i AKS: minne. available<750Mi , vilket innebär att en nod alltid måste ha minst 750 mi allocatable.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. När en värd unders tiger den tröskeln för tillgängligt minne, kommer kubelet att avsluta en av de poddar som körs för att frigöra minne på värddatorn och skydda den.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. Den här åtgärden utlöses när det tillgängliga minnet minskar efter 750Mi tröskel.This action is triggered once available memory decreases beyond the 750Mi threshold.

  2. Det andra värdet är en autoregressiva hastighet för de minnes reservationer som kubelet-daemonen ska fungera korrekt (Kube-reserverad).The second value is a regressive rate of memory reservations for the kubelet daemon to properly function (kube-reserved).

    • 25% av de första 4 GB minne25% of the first 4 GB of memory
    • 20% av nästa 4 GB minne (upp till 8 GB)20% of the next 4 GB of memory (up to 8 GB)
    • 10% av nästa 8 GB minne (upp till 16 GB)10% of the next 8 GB of memory (up to 16 GB)
    • 6% av nästa 112 GB minne (upp till 128 GB)6% of the next 112 GB of memory (up to 128 GB)
    • 2% av ett minne över 128 GB2% of any memory above 128 GB

Reglerna ovan för minne och PROCESSORALLOKERING används för att hålla agent-noderna felfria, inklusive vissa värd system poddar som är viktiga för kluster hälsan.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. Dessa allokeringsregler leder också till att noden rapporterar mindre allocatable minne och CPU än vanligt vis om den inte var en del av ett Kubernetes-kluster.These allocation rules also cause the node to report less allocatable memory and CPU than it normally would if it were not part of a Kubernetes cluster. Det går inte att ändra resurs reservationerna ovan.The above resource reservations can't be changed.

Om en nod till exempel erbjuder 7 GB, kommer den att rapportera 34% av minnet som inte allocatable, inklusive 750Mi för hård borttagning.For example, if a node offers 7 GB, it will report 34% of memory not allocatable including the 750Mi hard eviction threshold.

0.75 + (0.25*4) + (0.20*3) = 0.75GB + 1GB + 0.6GB = 2.35GB / 7GB = 33.57% reserved

Förutom reservationer för Kubernetes, reserverar den underliggande noden också en mängd processor-och minnes resurser för att underhålla OS-funktioner.In addition to reservations for Kubernetes itself, the underlying node OS also reserves an amount of CPU and memory resources to maintain OS functions.

För associerade metod tips, se metod tips för grundläggande funktioner i Schemaläggaren i AKS.For associated best practices, see Best practices for basic scheduler features in AKS.

NodpoolerNode pools

Noder i samma konfiguration grupperas tillsammans i noder i pooler .Nodes of the same configuration are grouped together into node pools . Ett Kubernetes-kluster innehåller en eller flera Node-pooler.A Kubernetes cluster contains one or more node pools. Det ursprungliga antalet noder och storlek definieras när du skapar ett AKS-kluster, vilket skapar en standardnod .The initial number of nodes and size are defined when you create an AKS cluster, which creates a default node pool . Denna standardnod i AKS innehåller de underliggande virtuella datorerna som kör dina agent-noder.This default node pool in AKS contains the underlying VMs that run your agent nodes.

Anteckning

För att säkerställa att klustret fungerar på ett tillförlitligt sätt bör du köra minst två (två) noder i standardnodens adresspool.To ensure your cluster operates reliably, you should run at least 2 (two) nodes in the default node pool.

När du skalar eller uppgraderar ett AKS-kluster utförs åtgärden mot standardnoden.When you scale or upgrade an AKS cluster, the action is performed against the default node pool. Du kan också välja att skala eller uppgradera en angiven Node-pool.You can also choose to scale or upgrade a specific node pool. För uppgraderings åtgärder schemaläggs körning av behållare på andra noder i Node-poolen tills alla noder har uppgraderats.For upgrade operations, running containers are scheduled on other nodes in the node pool until all the nodes are successfully upgraded.

Mer information om hur du använder flera Node-pooler i AKS finns i skapa och hantera flera noder för ett kluster i 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.

Node-väljareNode selectors

I ett AKS-kluster som innehåller flera resurspooler kan du behöva meddela Kubernetes Scheduler vilken Node-pool som ska användas för en specifik resurs.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. Till exempel ska ingångs styrenheter inte köras på Windows Server-noder.For example, ingress controllers shouldn't run on Windows Server nodes. Med Node-väljare kan du definiera olika parametrar, till exempel nodens operativ system, för att styra var Pod ska schemaläggas.Node selectors let you define various parameters, such as the node OS, to control where a pod should be scheduled.

Följande grundläggande exempel schemalägger en NGINX-instans på en Linux-nod med hjälp av Node-väljaren "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: mcr.microsoft.com/oss/nginx/nginx:1.15.12-alpine
  nodeSelector:
    "beta.kubernetes.io/os": linux

Mer information om hur du styr var poddar schemaläggs finns i metod tips för avancerade Scheduler-funktioner i AKS.For more information on how to control where pods are scheduled, see Best practices for advanced scheduler features in AKS.

PoddarPods

Kubernetes använder poddar för att köra en instans av programmet.Kubernetes uses pods to run an instance of your application. En POD representerar en enda instans av ditt program.A pod represents a single instance of your application. Poddar har vanligt vis en 1:1-mappning med en behållare, även om det finns avancerade scenarier där en POD kan innehålla flera behållare.Pods typically have a 1:1 mapping with a container, although there are advanced scenarios where a pod may contain multiple containers. Dessa poddar för flera behållare schemaläggs tillsammans på samma nod och tillåter att behållare delar relaterade resurser.These multi-container pods are scheduled together on the same node, and allow containers to share related resources.

När du skapar en POD kan du definiera resurs begär Anden för att begära en viss mängd CPU-eller minnes resurser.When you create a pod, you can define resource requests to request a certain amount of CPU or memory resources. Kubernetes Scheduler försöker schemalägga poddar att köra på en nod med tillgängliga resurser för att uppfylla begäran.The Kubernetes Scheduler tries to schedule the pods to run on a node with available resources to meet the request. Du kan också ange högsta antal resurs gränser som förhindrar att en specifik Pod förbrukar för mycket data bearbetnings resurser från den underliggande noden.You can also specify maximum resource limits that prevent a given pod from consuming too much compute resource from the underlying node. Ett bra tips är att inkludera resurs gränser för alla poddar som hjälper Kubernetes Scheduler att förstå vilka resurser som behövs och är tillåtna.A best practice is to include resource limits for all pods to help the Kubernetes Scheduler understand which resources are needed and permitted.

Mer information finns i Kubernetes poddar och Kubernetes Pod Lifecycle.For more information, see Kubernetes pods and Kubernetes pod lifecycle.

En pod är en logisk resurs, men behållarna är där program arbets belastningarna körs.A pod is a logical resource, but the container(s) are where the application workloads run. Poddar är vanligt vis tillfälliga, disponibla resurser och individuellt schemalagda poddar saknar några av funktionerna för hög tillgänglighet och redundans Kubernetes ger.Pods are typically ephemeral, disposable resources, and individually scheduled pods miss some of the high availability and redundancy features Kubernetes provides. I stället distribueras och hanteras poddar av Kubernetes- kontrollanter , till exempel distributions styrenheten.Instead, pods are deployed and managed by Kubernetes Controllers , such as the Deployment Controller.

Distributioner och YAML-manifestDeployments and YAML manifests

En distribution representerar en eller flera identiska poddar som hanteras av distributions styrenheten för Kubernetes.A deployment represents one or more identical pods, managed by the Kubernetes Deployment Controller. En distribution definierar antalet repliker (poddar) som ska skapas och Schemaläggaren för Kubernetes säkerställer att ytterligare poddar schemaläggs på felfria noder om poddar eller noder stöter på problem.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.

Du kan uppdatera distributioner för att ändra konfigurationen för poddar, behållar avbildning som används eller bifogad lagring.You can update deployments to change the configuration of pods, container image used, or attached storage. Distributions styrenheten tömmer och avslutar ett angivet antal repliker, skapar repliker från den nya distributions definitionen och fortsätter processen tills alla repliker i distributionen har uppdaterats.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.

De flesta tillstånds lösa program i AKS bör använda distributions modellen i stället för att schemalägga enskilda poddar.Most stateless applications in AKS should use the deployment model rather than scheduling individual pods. Kubernetes kan övervaka hälso tillstånd och status för distributioner för att säkerställa att antalet repliker som krävs körs i klustret.Kubernetes can monitor the health and status of deployments to ensure that the required number of replicas run within the cluster. När du bara schemalägger enskilda poddar startas poddar om, om det uppstår ett problem och inte omplaneras på felfria noder om deras aktuella nod påträffar ett problem.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.

Om ett program kräver ett kvorum av instanser för att alltid vara tillgängligt för hanterings beslut, vill du inte att en uppdaterings process ska störa den möjligheten.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. Pod avbrott i budgetar kan användas för att definiera hur många repliker i en distribution som kan tas offline under en uppdatering eller nod-uppgradering.Pod Disruption Budgets can be used to define how many replicas in a deployment can be taken down during an update or node upgrade. Om du till exempel har fem (5) repliker i distributionen kan du definiera ett Pod-avbrott på 4 för att endast tillåta att en replik tas bort/ombokas i taget.For example, if you have five (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. Precis som med Pod resurs gränser är det en bra idé att definiera Pod avbrotts budgetar för program som kräver att det alltid finns ett minsta antal repliker.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.

Distributioner skapas och hanteras vanligt vis med kubectl create eller kubectl apply .Deployments are typically created and managed with kubectl create or kubectl apply. Om du vill skapa en distribution definierar du en manifest fil i formatet YAML (YAML Ain't Markup Language).To create a deployment, you define a manifest file in the YAML (YAML Ain't Markup Language) format. I följande exempel skapas en grundläggande distribution av NGINX-webbservern.The following example creates a basic deployment of the NGINX web server. I distributionen anges tre (3) repliker som ska skapas, och port 80 måste vara öppen på behållaren.The deployment specifies three (3) replicas to be created, and requires port 80 to be open on the container. Resurs begär Anden och gränser definieras också för processor och minne.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: mcr.microsoft.com/oss/nginx/nginx:1.15.2-alpine
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: 250m
            memory: 64Mi
          limits:
            cpu: 500m
            memory: 256Mi

Mer komplexa program kan skapas genom att även inkludera tjänster som belastningsutjämnare i YAML-manifestet.More complex applications can be created by also including services such as load balancers within the YAML manifest.

Mer information finns i Kubernetes-distributioner.For more information, see Kubernetes deployments.

Paket hantering med HelmPackage management with Helm

En vanlig metod för att hantera program i Kubernetes är med Helm.A common approach to managing applications in Kubernetes is with Helm. Du kan bygga och använda befintliga offentliga Helm- diagram som innehåller en paketerad version av program koden och Kubernetes yaml-manifest för att distribuera resurser.You can build and use existing public Helm charts that contain a packaged version of application code and Kubernetes YAML manifests to deploy resources. Dessa Helm-diagram kan lagras lokalt eller ofta i en fjärrlagringsplats, till exempel ett Azure Container Registry Helm-diagram lagrings platsen.These Helm charts can be stored locally, or often in a remote repository, such as an Azure Container Registry Helm chart repo.

Om du vill använda Helm installerar du Helm-klienten på datorn eller använder Helm-klienten i Azure Cloud Shell.To use Helm, install the Helm client on your computer, or use the Helm client in the Azure Cloud Shell. Du kan söka efter eller skapa Helm-diagram med klienten och sedan installera dem i ditt Kubernetes-kluster.You can search for or create Helm charts with the client, and then install them to your Kubernetes cluster. Mer information finns i Installera befintliga program med Helm i AKS.For more information, see Install existing applications with Helm in AKS.

StatefulSets och DaemonSetsStatefulSets and DaemonSets

Distributions styrenheten använder Kubernetes Scheduler för att köra ett angivet antal repliker på alla tillgängliga noder med tillgängliga resurser.The Deployment Controller uses the Kubernetes Scheduler to run a given number of replicas on any available node with available resources. Den här metoden för att använda distributioner kan vara tillräckligt för tillstånds lösa program, men inte för program som kräver en beständig namngivnings konvention eller lagring.This approach of using deployments may be sufficient for stateless applications, but not for applications that require a persistent naming convention or storage. För program som kräver att en replik finns på varje nod, eller valda noder, i ett kluster, tittar distributions hanteraren inte på hur repliker distribueras mellan noderna.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.

Det finns två Kubernetes-resurser som låter dig hantera följande typer av program:There are two Kubernetes resources that let you manage these types of applications:

  • StatefulSets – underhålla program tillstånd bortom en enskild Pod-livscykel, till exempel lagring.StatefulSets - Maintain the state of applications beyond an individual pod lifecycle, such as storage.
  • DaemonSets – se till att en instans körs på varje nod, tidigt i Start processen för Kubernetes.DaemonSets - Ensure a running instance on each node, early in the Kubernetes bootstrap process.

StatefulSetsStatefulSets

Modern program utveckling syftar ofta till tillstånds lösa program, men StatefulSets kan användas för tillstånds känsliga program, till exempel program som innehåller databas komponenter.Modern application development often aims for stateless applications, but StatefulSets can be used for stateful applications, such as applications that include database components. En StatefulSet liknar en distribution i som en eller flera identiska poddar skapas och hanteras.A StatefulSet is similar to a deployment in that one or more identical pods are created and managed. Repliker i en StatefulSet följer en korrekt, sekventiell metod för distribution, skalning, uppgraderingar och avslutning.Replicas in a StatefulSet follow a graceful, sequential approach to deployment, scale, upgrades, and terminations. Med en StatefulSet (som repliker omplaneras) namngivnings konventionen, nätverks namn och lagrings utrymme.With a StatefulSet (as replicas are rescheduled) the naming convention, network names, and storage persist.

Du definierar programmet i YAML-format med kind: StatefulSet , och StatefulSet-kontrollanten hanterar sedan distributionen och hanteringen av de nödvändiga replikerna.You define the application in YAML format using kind: StatefulSet, and the StatefulSet Controller then handles the deployment and management of the required replicas. Data skrivs till beständig lagring, som tillhandahålls av Azure Managed Disks eller Azure Files.Data is written to persistent storage, provided by Azure Managed Disks or Azure Files. Med StatefulSets förblir den underliggande beständiga lagringen även om StatefulSet tas bort.With StatefulSets, the underlying persistent storage remains even when the StatefulSet is deleted.

Mer information finns i Kubernetes StatefulSets.For more information, see Kubernetes StatefulSets.

Repliker i en StatefulSet schemaläggs och körs över alla tillgängliga noder i ett AKS-kluster.Replicas in a StatefulSet are scheduled and run across any available node in an AKS cluster. Om du behöver se till att minst en POD i uppsättningen körs på en nod kan du i stället använda en DaemonSet.If you need to ensure that at least one pod in your Set runs on a node, you can instead use a DaemonSet.

DaemonSetsDaemonSets

För specifik logg samling eller övervaknings behov kan du behöva köra en viss Pod på alla eller valda noder.For specific log collection or monitoring needs, you may need to run a given pod on all, or selected, nodes. En DaemonSet används återigen för att distribuera en eller flera identiska poddar, men DaemonSet-styrenheten säkerställer att varje nod som anges kör en instans av 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.

DaemonSet-kontrollanten kan schemalägga poddar på noderna tidigt i kluster start processen, innan standard-Kubernetes Scheduler har startat.The DaemonSet Controller can schedule pods on nodes early in the cluster boot process, before the default Kubernetes scheduler has started. Den här funktionen säkerställer att poddar i en DaemonSet startas innan traditionella poddar i en distribution eller StatefulSet schemaläggs.This ability ensures that the pods in a DaemonSet are started before traditional pods in a Deployment or StatefulSet are scheduled.

Som StatefulSets definieras en DaemonSet som en del av en YAML-definition med hjälp av kind: DaemonSet .Like StatefulSets, a DaemonSet is defined as part of a YAML definition using kind: DaemonSet.

Mer information finns i Kubernetes DaemonSets.For more information, see Kubernetes DaemonSets.

Anteckning

Om du använder tillägg för virtuella noderkommer DaemonSets inte att skapa poddar på den virtuella noden.If using the Virtual Nodes add-on, DaemonSets will not create pods on the virtual node.

NamnrymderNamespaces

Kubernetes-resurser, till exempel poddar och distributioner, grupperas logiskt i ett namn område .Kubernetes resources, such as pods and Deployments, are logically grouped into a namespace . Dessa grupperingar ger ett sätt att logiskt dela upp ett AKS-kluster och begränsa åtkomsten till att skapa, Visa eller hantera resurser.These groupings provide a way to logically divide an AKS cluster and restrict access to create, view, or manage resources. Du kan till exempel skapa namn områden för att separera affärs grupper.You can create namespaces to separate business groups, for example. Användare kan bara interagera med resurser inom de tilldelade namn områdena.Users can only interact with resources within their assigned namespaces.

Kubernetes namn områden som logiskt delar resurser och program

När du skapar ett AKS-kluster är följande namn rymder tillgängliga:When you create an AKS cluster, the following namespaces are available:

  • standard – det här namn området är där poddar och distributioner skapas som standard när inget anges.default - This namespace is where pods and deployments are created by default when none is provided. I mindre miljöer kan du distribuera program direkt till standard namn området utan att skapa ytterligare logiska separationer.In smaller environments, you can deploy applications directly into the default namespace without creating additional logical separations. När du interagerar med Kubernetes-API: t, till exempel med kubectl get pods , används standard namn området när inget anges.When you interact with the Kubernetes API, such as with kubectl get pods, the default namespace is used when none is specified.
  • Kube-system – det här namn området är där kärn resurser finns, till exempel nätverks funktioner som DNS och proxy eller Kubernetes-instrumentpanelen.kube-system - This namespace is where core resources exist, such as network features like DNS and proxy, or the Kubernetes dashboard. Du distribuerar vanligt vis inte dina egna program till det här namn området.You typically don't deploy your own applications into this namespace.
  • Kube – det här namn området används vanligt vis inte, men kan användas för att visa resurser över hela klustret och kan visas av alla användare.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.

Mer information finns i Kubernetes-namnområden.For more information, see Kubernetes namespaces.

Nästa stegNext steps

Den här artikeln beskriver några av de viktigaste Kubernetes-komponenterna och hur de gäller för AKS-kluster.This article covers some of the core Kubernetes components and how they apply to AKS clusters. Mer information om kärn Kubernetes-och AKS-koncept finns i följande artiklar:For more information on core Kubernetes and AKS concepts, see the following articles: