Alapvető Kubernetes-fogalmak az Azure Kubernetes Service-hez

  • Cikk

Az alkalmazásfejlesztés továbbra is a tárolóalapú megközelítés felé halad, ami növeli az erőforrások vezénylését és kezelését. Vezető platformként a Kubernetes megbízható ütemezést biztosít a hibatűrő alkalmazás-számítási feladatokhoz. A felügyelt Kubernetes-ajánlat, az Azure Kubernetes Service (AKS) tovább egyszerűsíti a tárolóalapú alkalmazások üzembe helyezését és kezelését.

Ez a cikk az alapvető fogalmakat ismerteti:

  • Kubernetes-infrastruktúra-összetevők:

    • vezérlősík
    • Csomópontok
    • csomópontkészletek

  • Számítási feladatok erőforrásai:

    • Hüvely
    • Telepítések
    • Készletek

  • Erőforrások csoportosítása névterek használatával.

Mi az a Kubernetes?

A Kubernetes egy gyorsan fejlődő platform, amely a tárolóalapú alkalmazásokat és azok kapcsolódó hálózati és tárolási összetevőit kezeli. A Kubernetes az alkalmazás számítási feladataira összpontosít, nem a mögöttes infrastruktúra-összetevőkre. A Kubernetes deklaratív megközelítést biztosít az üzemelő példányokhoz, amelyet a felügyeleti műveletekhez használható, robusztus API-k nyújtanak.

Modern, hordozható, mikroszolgáltatás-alapú alkalmazásokat hozhat létre és futtathat a Kubernetes használatával az alkalmazásösszetevők rendelkezésre állásának vezénylésére és kezelésére. A Kubernetes mind az állapot nélküli, mind az állapotalapú alkalmazásokat támogatja, ahogy a csapatok a mikroszolgáltatás-alapú alkalmazások bevezetésén haladnak előre.

Nyílt platformként a Kubernetes lehetővé teszi az alkalmazások létrehozását az előnyben részesített programozási nyelv, operációs rendszer, kódtárak vagy üzenetkezelő busz használatával. A meglévő folyamatos integrációs és folyamatos kézbesítési (CI/CD) eszközök integrálhatók a Kubernetes-lel a kiadások ütemezéséhez és üzembe helyezéséhez.

Az AKS egy felügyelt Kubernetes-szolgáltatást biztosít, amely csökkenti az üzembe helyezés és az alapvető felügyeleti feladatok összetettségét, például a frissítési koordinációt. Az Azure platform kezeli az AKS vezérlősíkot, és csak az alkalmazásokat futtató AKS-csomópontokért kell fizetnie.

Kubernetes-fürtarchitektúra

Egy Kubernetes-fürt két összetevőre osztható:

  • Vezérlősík: az alapvető Kubernetes-szolgáltatásokat és az alkalmazás-számítási feladatok vezénylését biztosítja.
  • Csomópontok: futtassa az alkalmazás számítási feladatait.

Kubernetes control plane and node components

Vezérlősík

AKS-fürt létrehozásakor automatikusan létrejön és konfigurálódik egy vezérlősík. Ez a vezérlősík díjmentesen biztosított a felhasználó elől rejtett, felügyelt Azure-erőforrás formájában. Csak az AKS-fürthöz kapcsolódó csomópontokért kell kifizetnie. A vezérlősík és erőforrásai abban a régióban találhatók, ahol a fürtöt létrehozta.

A vezérlősík a következő alapvető Kubernetes-összetevőket tartalmazza:

Összetevő Leírás
kube-apiserver Az API-kiszolgáló az alapul szolgáló Kubernetes API-k felfedése. Ez az összetevő biztosítja a felügyeleti eszközök, például kubectl a Kubernetes-irányítópult interakcióját.
etcd A Kubernetes-fürt és -konfiguráció állapotának fenntartása érdekében a magas rendelkezésre állású etcd kulcsértéktár a Kubernetesben.
kube-scheduler Alkalmazások létrehozásakor vagy méretezésekor az Ütemező határozza meg, hogy mely csomópontok futtathatják a számítási feladatot, és indíthatják el őket.
kube-controller-manager A Vezérlőkezelő számos kisebb vezérlőt felügyel, amelyek olyan műveleteket hajtanak végre, mint a podok replikálása és a csomópontműveletek kezelése.

Az AKS egy bérlős vezérlősíkot biztosít dedikált API-kiszolgálóval, ütemezővel stb. Ön határozza meg a csomópontok számát és méretét, és az Azure platform konfigurálja a vezérlősík és a csomópontok közötti biztonságos kommunikációt. A vezérlősíkkal való interakció a Kubernetes API-kkal történik, például kubectl a Kubernetes-irányítópulton.

Bár nem kell konfigurálnia az összetevőket (például egy magas rendelkezésre állású stb. tárolót) ezzel a felügyelt vezérlősíkkal, nem férhet hozzá közvetlenül a vezérlősíkhoz. A Kubernetes vezérlősíkjának és csomópontfrissítéseinek vezénylése az Azure CLI-n vagy az Azure Portalon keresztül történik. A lehetséges problémák elhárításához tekintse át a vezérlősík naplóit az Azure Monitor naplóiban.

A vezérlősík konfigurálásához vagy közvetlen eléréséhez helyezzen üzembe egy ön által felügyelt Kubernetes-fürtöt az Azure-fürt API-szolgáltatójával.

A kapcsolódó ajánlott eljárásokért tekintse meg a fürtbiztonságra és a frissítésre vonatkozó ajánlott eljárásokat az AKS-ben.

Az AKS költségkezelési információiért tekintse meg az AKS költség alapjait és az AKS díjszabását.

Csomópontok és csomópontkészletek

Az alkalmazások és a támogató szolgáltatások futtatásához Kubernetes-csomópontra van szükség. Az AKS-fürtök legalább egy csomóponttal, egy Azure-beli virtuális géppel (VM) rendelkeznek, amely a Kubernetes-csomópont összetevőit és a tároló futtatókörnyezetét futtatja.

Összetevő Leírás
kubelet A kubernetes-ügynök, amely feldolgozza a vezérlősíkról érkező vezénylési kéréseket, valamint ütemezi és futtatja a kért tárolókat.
kube-proxy Minden csomóponton kezeli a virtuális hálózatkezelést. A proxy irányítja a hálózati forgalmat, és kezeli a szolgáltatások és podok IP-címkezelését.
tároló futtatókörnyezete Lehetővé teszi a tárolóalapú alkalmazások futtatását és használatát további erőforrásokkal, például a virtuális hálózattal vagy a tárolóval. A Linux-csomópontkészletekhez készült Kubernetes 1.19+-os verzióját használó AKS-fürtök tároló-futtatókörnyezetként használhatók containerd . A Windows-csomópontkészletekhez containerd készült Kubernetes 1.20-es verziójától kezdve előzetes verzióban használható a tároló futtatókörnyezetéhez, de a Docker továbbra is az alapértelmezett tároló-futtatókörnyezet. A kubernetes csomópontkészletekhez való korábbi verzióit használó AKS-fürtök a Dockert használják tároló-futtatókörnyezetként.

Azure virtual machine and supporting resources for a Kubernetes node

A csomópontok Azure-beli virtuálisgép-mérete határozza meg a processzorokat, a memóriát, a méretet és az elérhető tárolási típust (például a nagy teljesítményű SSD-t vagy a normál HDD-t). Tervezze meg a csomópont méretét, hogy az alkalmazások nagy mennyiségű processzort és memóriát vagy nagy teljesítményű tárterületet igényelnek-e. Skálázza fel az AKS-fürt csomópontjainak számát az igények kielégítése érdekében. A skálázással kapcsolatos további információkért tekintse meg az alkalmazások skálázási beállításait az AKS-ben.

Az AKS-ben a fürt csomópontjaihoz tartozó virtuálisgép-rendszerkép Ubuntu Linuxon, Azure Linuxon vagy Windows Server 2019-en alapul. Amikor létrehoz egy AKS-fürtöt, vagy kibővíti a csomópontok számát, az Azure-platform automatikusan létrehozza és konfigurálja a kért virtuális gépek számát. Az ügynökcsomópontok számlázása standard virtuális gépekként történik, így a rendszer automatikusan alkalmazza a virtuálisgép-méretre vonatkozó kedvezményeket (beleértve az Azure-foglalásokat is).

Felügyelt lemezek esetén az alapértelmezett lemezméret és -teljesítmény a kiválasztott virtuálisgép-termékváltozat és vCPU-szám alapján lesz hozzárendelve. További információ: Operációsrendszer-lemez alapértelmezett méretezése.

Ha speciális konfigurálásra és vezérlésre van szüksége a Kubernetes-csomópont tároló-futtatókörnyezetében és operációs rendszerében, üzembe helyezhet egy ön által felügyelt fürtöt az Azure Fürt API-szolgáltatóval.

Erőforrás-foglalások

Az AKS csomóponterőforrásokkal segíti a csomópont működését a fürt részeként. Ez a használat eltérést okozhat a csomópont teljes erőforrásai és az AKS-ben kiosztható erőforrások között. Ezeket az információkat a felhasználók által üzembe helyezett podok kéréseinek és korlátainak beállításakor jegyezze fel.

Egy csomópont lefoglalható erőforrásainak megkereséséhez futtassa a következőt:

kubectl describe node [NODE_NAME]

A csomópontok teljesítményének és működésének fenntartása érdekében az AKS minden csomóponton fenntartja az erőforrásokat. Ahogy a csomópontok egyre nagyobbak lesznek az erőforrásokban, az erőforrás-foglalás növekszik a felhasználó által üzembe helyezett podok felügyeletére való nagyobb igény miatt.

Feljegyzés

Az AKS-bővítmények, például a Container Elemzések (OMS) használata további csomóponterőforrásokat fog használni.

Kétféle erőforrás van fenntartva:

CPU

A fenntartott CPU a csomópont típusától és a fürt konfigurációtól függ, ami a további funkciók futtatása miatt kevesebb kiosztható processzort okozhat.

Processzormagok a gazdagépen 0 2 4 8 16 32 64
Kube-reserved (millicores) 60 100 140 180 260 420 740

Memory (Memória)

Az AKS által használt memória két érték összegét tartalmazza.

Fontos

Az AKS 1.29 előzetes verziója 2024 januárjában érhető el, és tartalmazza a memóriafoglalások bizonyos módosításait. Ezeket a módosításokat a következő szakaszban találja.

AKS 1.29 és újabb verziók

  1. kubelet A démon alapértelmezés szerint rendelkezik a memory.available<100Mi kiürítési szabálysal. Ez biztosítja, hogy a csomópontok mindig legalább 100Mi-et lefoglalhatók. Ha egy gazdagép a rendelkezésre álló memória küszöbértéke alatt van, az kubelet aktiválja az egyik futó pod leállítását, és felszabadítja a memóriát a gazdagépen.

  2. A memóriafoglalások aránya a következő kisebb érték szerint van beállítva: 20 MB * A csomóponton támogatott maximális podok száma + 50 MB , vagy a teljes rendszermemória-erőforrás 25%-a.

    Példák:

    • Ha a virtuális gép 8 GB memóriát biztosít, és a csomópont legfeljebb 30 podot támogat, az AKS 20 MB * 30 maximális podot + 50 MB = 650 MB-ot foglal le a kube-reserved számára. Allocatable space = 8GB - 0.65GB (kube-reserved) - 0.1GB (eviction threshold) = 7.25GB or 90.625% allocatable.
    • Ha a virtuális gép 4 GB memóriát biztosít, és a csomópont legfeljebb 70 podot támogat, az AKS 25% * 4 GB = 1000 MB-ot foglal le a kube-reserved számára, mivel ez kevesebb, mint 20 MB * 70 Maximális pod + 50 MB = 1450 MB.

    További információ: Csomópontonkénti maximális podok konfigurálása egy AKS-fürtben.

AKS-verziók az 1.29-et megelőzően

  1. kubelet A démon minden Kubernetes-ügynökcsomópontra telepítve van a tárolólétrehozás és -leállítás kezeléséhez. Alapértelmezés szerint az AKS-ben kubelet a démon rendelkezik a memory.available<750Mi kiürítési szabálysal, így a csomópontnak mindig legalább 750Mi kioszthatónak kell lennie. Ha egy gazdagép a rendelkezésre álló memóriaküszöb alatt van, az kubelet eseményindító leállítja az egyik futó podot, és memóriát szabadít fel a gazdagépen.

  2. A kubelet démon memóriafoglalásainak regresszív aránya a megfelelő működéshez (kube-reserved).

    • Az első 4 GB memória 25%-a
    • A következő 4 GB memória 20%-a (legfeljebb 8 GB)
    • A következő 8 GB memória 10%-a (legfeljebb 16 GB)
    • A következő 112 GB memória 6%-a (legfeljebb 128 GB)
    • 128 GB feletti memória 2%-a

Feljegyzés

Az AKS további 2 GB-ot foglal le a windowsos csomópontok rendszerfolyamataihoz, amelyek nem részei a számított memóriának.

A memória- és CPU-foglalási szabályok a következőkre vannak kialakítva:

  • Az ügynökcsomópontok kifogástalan állapotának megőrzése, beleértve néhány olyan üzemeltetési rendszer podot, amely kritikus fontosságú a fürt állapota szempontjából.
  • A csomópont kevesebb kiosztható memóriát és processzort jelent, mint amennyit egy Kubernetes-fürt részeként jelentene.

A fenti erőforrás-foglalások nem módosíthatók.

Ha például egy csomópont 7 GB-ot kínál, a memória 34%-át nem lehet lefoglalni, beleértve a 750Mi kemény kiürítési küszöbértéket is.

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

A Kubernetes-re vonatkozó foglalások mellett a mögöttes csomópont operációs rendszere az operációs rendszer funkcióinak fenntartásához is fenntart egy mennyiségű PROCESSZOR- és memóriaerőforrást.

A kapcsolódó ajánlott eljárásokért tekintse meg az AKS alapszintű ütemezőfunkcióinak ajánlott eljárásait.

Csomópontkészletek

Feljegyzés

Az Azure Linux-csomópontkészlet általánosan elérhető (GA). Az előnyökről és az üzembe helyezés lépéseiről az AKS-hez készült Azure Linux Container Host bemutatása című témakörben olvashat.

Az azonos konfigurációban lévő csomópontok csomópontkészletekbe vannak csoportosítva. A Kubernetes-fürtök legalább egy csomópontkészletet tartalmaznak. A csomópontok kezdeti száma és mérete egy AKS-fürt létrehozásakor lesz meghatározva, amely létrehoz egy alapértelmezett csomópontkészletet. Az AKS alapértelmezett csomópontkészlete az ügynökcsomópontokat futtató mögöttes virtuális gépeket tartalmazza.

Feljegyzés

A fürt megbízható működésének biztosítása érdekében legalább két (2) csomópontot kell futtatnia az alapértelmezett csomópontkészletben.

Az AKS-fürtöket az alapértelmezett csomópontkészletre skálázhatja vagy frissítheti. Egy adott csomópontkészlet skálázását vagy frissítését is választhatja. Frissítési műveletek esetén a futó tárolók a csomópontkészlet más csomópontjaira lesznek ütemezve, amíg az összes csomópont frissítése sikeresen meg nem fejeződik.

További információ a több csomópontkészlet AKS-ben való használatáról: Több csomópontkészlet létrehozása fürthöz az AKS-ben.

Csomópontválasztók

Több csomópontkészlettel rendelkező AKS-fürtön előfordulhat, hogy meg kell adnia a Kubernetes Schedulernek, hogy melyik csomópontkészletet használja egy adott erőforráshoz. A bejövőforgalom-vezérlők például nem futtathatók Windows Server-csomópontokon.

A csomópontválasztók segítségével különböző paramétereket határozhat meg, például a csomópont operációs rendszerét, így szabályozhatja, hogy a podok hol legyenek ütemezve.

Az alábbi egyszerű példa egy NGINX-példányt ütemez egy Linux-csomóponton a "kubernetes.io/os": linux csomópontválasztó használatával:

kind: Pod
apiVersion: v1
metadata:
  name: nginx
spec:
  containers:
    - name: myfrontend
      image: mcr.microsoft.com/oss/nginx/nginx:1.15.12-alpine
  nodeSelector:
    "kubernetes.io/os": linux

A podok ütemezésének szabályozásáról további információt az AKS speciális ütemezőfunkcióinak ajánlott eljárásaiban talál.

Csomópont-erőforráscsoport

AKS-fürt létrehozásakor meg kell adnia egy erőforráscsoportot a fürterőforrás létrehozásához. Az erőforráscsoport mellett az AKS-erőforrás-szolgáltató egy külön erőforráscsoportot is létrehoz és kezel, amelyet csomópont-erőforráscsoportnak hívnak. A csomópont erőforráscsoportja a következő infrastruktúra-erőforrásokat tartalmazza:

  • A csomópontkészletek összes csomópontjának virtuálisgép-méretezési csoportjai és virtuális gépei
  • A fürt virtuális hálózata
  • A fürt tárhelye

A csomópont erőforráscsoportja alapértelmezés szerint egy névhez van hozzárendelve, például MC_myResourceGroup_myAKSCluster_eastus. A fürt létrehozása során megadhatja a csomópont erőforráscsoportjához rendelt nevet is. Az AKS-fürt törlésekor az AKS-erőforrás-szolgáltató automatikusan törli a csomópont erőforráscsoportját.

A csomópont erőforráscsoportja a következő korlátozásokkal rendelkezik:

  • A csomópont erőforráscsoporthoz nem adhat meg meglévő erőforráscsoportot.
  • Nem adhat meg másik előfizetést a csomópont erőforráscsoporthoz.
  • A fürt létrehozása után nem módosíthatja a csomópont erőforráscsoportjának nevét.
  • A csomópont erőforráscsoporton belül nem adhatja meg a felügyelt erőforrások nevét.
  • A csomópont erőforráscsoporton belül nem módosíthatja és nem törölheti a felügyelt erőforrások Azure-beli címkéit.

Ha módosítja vagy törli az Azure által létrehozott címkéket és más erőforrástulajdonságokat a csomópont erőforráscsoportjában, váratlan eredményeket kaphat, például skálázási és frissítési hibákat. Mivel az AKS kezeli a csomópont-erőforráscsoport infrastruktúrájának életciklusát, a módosítások nem támogatott állapotba helyezik át a fürtöt.

Gyakori eset, amikor az ügyfelek címkéken keresztül szeretnék módosítani az erőforrásokat. Az AKS lehetővé teszi olyan címkék létrehozását és módosítását, amelyeket a csomópont-erőforráscsoportban lévő erőforrásokra propagáltak, és ezeket a címkéket a fürt létrehozásakor vagy frissítésekor is hozzáadhatja. Előfordulhat, hogy egyéni címkéket szeretne létrehozni vagy módosítani, például egy üzleti egység vagy költséghely hozzárendeléséhez. Ez a felügyelt erőforráscsoport hatókörével rendelkező Azure-szabályzatok létrehozásával is megvalósítható.

Az Azure által létrehozott címkék módosítása az AKS-fürt csomóponterőforrás-csoportjában lévő erőforrásokon nem támogatott művelet, amely megszakítja a szolgáltatásiszint-célkitűzést (SLO). További információ: Az AKS szolgáltatásszintű szerződést kínál?

Ha csökkenteni szeretné a csomópont erőforráscsoportjában a fürtöket érintő változások esélyét, engedélyezheti a csomóponti erőforráscsoport zárolását, hogy megtagadási hozzárendelést alkalmazzon az AKS-erőforrásokra. További információt az AKS fürtkonfigurációjában talál.

Figyelmeztetés

Ha nincs engedélyezve a csomóponterőforrás-csoport zárolása, közvetlenül módosíthatja a csomópont erőforráscsoportjának bármely erőforrását. Ha közvetlenül módosítja az erőforrásokat a csomópont erőforráscsoportjában, a fürt instabillá vagy nem válaszolhatóvá válhat.

Podok

A Kubernetes podokkal futtatja az alkalmazás egy példányát. A pod az alkalmazás egyetlen példányát jelöli.

A podok általában 1:1-alapú leképezéssel rendelkeznek egy tárolóval. Speciális helyzetekben a podok több tárolót is tartalmazhatnak. A többtárolós podok ugyanazon a csomóponton vannak ütemezve, és lehetővé teszik a tárolók számára a kapcsolódó erőforrások megosztását.

Pod létrehozásakor definiálhat erőforrás-kérelmeket egy bizonyos mennyiségű CPU- vagy memóriaerőforrás lekéréséhez. A Kubernetes Scheduler úgy próbálja teljesíteni a kérést, hogy a podokat úgy ütemezi, hogy az elérhető erőforrásokkal rendelkező csomóponton fusson. Megadhatja a maximális erőforráskorlátokat is, hogy a pod ne használjon túl sok számítási erőforrást a mögöttes csomópontból. Az ajánlott eljárás az, hogy az összes pod erőforráskorlátjait belefoglalja, hogy a Kubernetes Scheduler azonosíthassa a szükséges, engedélyezett erőforrásokat.

További információ: Kubernetes-podok és Kubernetes-podok életciklusa.

A pod egy logikai erőforrás, de az alkalmazás számítási feladatai a tárolókon futnak. A podok általában rövid élettartamú, eldobható erőforrások. Az egyénileg ütemezett podok hiányoznak a magas rendelkezésre állás és a redundancia kubernetes-funkciói közül. Ehelyett a podokat a Kubernetes-vezérlők , például az üzembehelyezési vezérlő helyezik üzembe és felügyelik.

Üzembe helyezések és YAML-jegyzékek

Az üzembe helyezés azonos podokat jelöl, amelyeket a Kubernetes üzembehelyezési vezérlő felügyel. Az üzembe helyezés határozza meg a létrehozandó podreplikák számát. A Kubernetes Scheduler biztosítja, hogy a podok vagy csomópontok problémák esetén további podokat ütemezzen kifogástalan állapotú csomópontokra.

Az üzemelő példányokat frissítheti a podok, a használt tárolólemezkép vagy a csatolt tároló konfigurációjának módosításához. Az üzembehelyezési vezérlő:

  • Adott számú replikát ürít ki és zár le.
  • Replikákat hoz létre az új üzembehelyezési definícióból.
  • A folyamat addig folytatódik, amíg az üzembe helyezés összes replikája frissül.

Az AKS-ben a legtöbb állapot nélküli alkalmazásnak az egyes podok ütemezése helyett az üzembe helyezési modellt kell használnia. A Kubernetes figyelheti az üzembe helyezés állapotát és állapotát, hogy a szükséges számú replika fusson a fürtben. Ha egyénileg van ütemezve, a podok nem indulnak újra, ha problémát tapasztalnak, és nem ütemezhetők át kifogástalan állapotú csomópontokra, ha az aktuális csomópontjuk problémát tapasztal.

Nem szeretné megszakítani a felügyeleti döntéseket frissítési folyamattal, ha az alkalmazáshoz minimális számú elérhető példányra van szükség. A podkimaradási költségvetések határozzák meg, hogy egy üzemelő példány hány replikáját lehet levenni egy frissítés vagy csomópont frissítése során. Ha például öt (5) replika van az üzemelő példányban, megadhat egy 4 (négy) podkimaradást, hogy egyszerre csak egy replikát töröljön vagy ütemezzen újra. A poderőforrás-korlátokhoz hasonlóan az ajánlott eljárás az olyan alkalmazások podkimaradási költségvetésének meghatározása, amelyeknél a replikák minimális száma mindig jelen van.

Az üzemelő példányok létrehozása és kezelése általában a vagy kubectl applya kubectl create . Hozzon létre egy üzembe helyezést egy jegyzékfájl YAML formátumban történő definiálásával.

Az alábbi példa az NGINX-webkiszolgáló alapszintű üzembe helyezését hozza létre. Az üzembe helyezés három (3) replikát határoz meg, és a tárolón a 80-at kell megnyitni. Az erőforrás-kérelmek és a korlátok a processzorra és a memóriára is vonatkoznak.

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

A YAML-jegyzékfájl üzembehelyezési specifikációinak részletezése a következő:

Specifikáció Leírás
.apiVersion Megadja az erőforrás létrehozásakor használni kívánt API-csoportot és API-erőforrást.
.kind Megadja a létrehozni kívánt erőforrás típusát.
.metadata.name Megadja az üzembe helyezés nevét. Ez a fájl futtatja az nginx-lemezképet a Docker Hubról.
.spec.replicas Megadja, hogy hány podot kell létrehozni. Ez a fájl három duplikált podot hoz létre.
.spec.selector Meghatározza, hogy az üzembe helyezés mely podokat érinti.
.spec.selector.matchLabels {key, value} párok térképét tartalmazza, amelyek lehetővé teszik, hogy az üzembe helyezés megkeresse és kezelje a létrehozott podokat.
.spec.selector.matchLabels.app Meg kell egyeznie .spec.template.metadata.labels.
.spec.template.labels Megadja az objektumhoz csatolt {key, value} párokat.
.spec.template.app Meg kell egyeznie .spec.selector.matchLabels.
.spec.spec.containers Megadja a podhoz tartozó tárolók listáját.
.spec.spec.containers.name A DNS-címkeként megadott tároló nevét adja meg.
.spec.spec.containers.image Megadja a tárolórendszerkép nevét.
.spec.spec.containers.ports Megadja a tárolóból közzéteendő portok listáját.
.spec.spec.containers.ports.containerPort Megadja a pod IP-címén közzéteendő portok számát.
.spec.spec.resources Megadja a tároló által igényelt számítási erőforrásokat.
.spec.spec.resources.requests Megadja a szükséges számítási erőforrások minimális mennyiségét.
.spec.spec.resources.requests.cpu Megadja a minimálisan szükséges processzormennyiséget.
.spec.spec.resources.requests.memory Megadja a minimálisan szükséges memóriamennyiséget.
.spec.spec.resources.limits Megadja az engedélyezett számítási erőforrások maximális mennyiségét. Ezt a korlátot a kubelet kényszeríti ki.
.spec.spec.resources.limits.cpu Megadja a maximálisan engedélyezett processzormennyiséget. Ezt a korlátot a kubelet kényszeríti ki.
.spec.spec.resources.limits.memory Megadja az engedélyezett memória maximális mennyiségét. Ezt a korlátot a kubelet kényszeríti ki.

Összetettebb alkalmazások hozhatók létre úgy, hogy a YAML-jegyzékbe belevesznek szolgáltatásokat (például terheléselosztókat).

További információ: Kubernetes-környezetek.

Csomagkezelés a Helmel

A Helmt gyakran használják a Kubernetes-alkalmazások kezelésére. Az erőforrásokat olyan meglévő nyilvános Helm-diagramok létrehozásával és használatával helyezheti üzembe, amelyek az alkalmazáskód és a Kubernetes YAML-jegyzékek csomagolt verzióját tartalmazzák. A Helm-diagramokat tárolhatja helyileg vagy egy távoli adattárban, például egy Azure Container Registry Helm-diagram-adattárban.

A Helm használatához telepítse a Helm-ügyfelet a számítógépre, vagy használja a Helm-ügyfelet az Azure Cloud Shellben. Keressen vagy hozzon létre Helm-diagramokat, majd telepítse őket a Kubernetes-fürtbe. További információ: Meglévő alkalmazások telepítése a Helmrel az AKS-ben.

StatefulSets és DaemonSets

A Kubernetes Schedulerrel az üzembehelyezési vezérlő replikákat futtat bármely elérhető, elérhető erőforrásokkal rendelkező csomóponton. Bár ez a megközelítés elegendő lehet az állapot nélküli alkalmazásokhoz, az üzembehelyezési vezérlő nem ideális olyan alkalmazásokhoz, amelyekhez a következők szükségesek:

  • Állandó elnevezési konvenció vagy tárolás.
  • Egy replika, amely a fürtön belüli egyes csomópontokon található.

Két Kubernetes-erőforrás azonban lehetővé teszi az ilyen típusú alkalmazások kezelését:

  • A StatefulSets az egyes pod-életciklusokon túl is fenntartja az alkalmazások állapotát.
  • A DaemonSets minden csomóponton biztosít egy futó példányt a Kubernetes rendszerindítási folyamatának korai szakaszában.

StatefulSets

A modern alkalmazásfejlesztés gyakran állapot nélküli alkalmazásokat céloz meg. Az állapotalapú alkalmazásokhoz, például az adatbázis-összetevőkhöz hasonlóan a StatefulSeteket is használhatja. Az üzembe helyezésekhez hasonlóan a StatefulSet is létrehoz és kezel legalább egy azonos podot. A StatefulSet replikái az üzembe helyezés, a méretezés, a frissítés és a leállítás elegáns, szekvenciális megközelítését követik. Az elnevezési konvenció, a hálózatnevek és a tárterület megmarad, mivel a replikák ütemezve vannak egy StatefulSettel.

Adja meg az alkalmazást YAML formátumban a következő használatával kind: StatefulSet: . Innen a StatefulSet-vezérlő kezeli a szükséges replikák üzembe helyezését és kezelését. Az adatok az Azure Managed Disks vagy az Azure Files által biztosított állandó tárolóba lesznek írva. A StatefulSets esetén az alapul szolgáló állandó tároló akkor is megmarad, ha a StatefulSet törlődik.

További információ: Kubernetes StatefulSets.

A StatefulSet replikái ütemezve vannak, és egy AKS-fürt bármely elérhető csomópontja között futnak. Ha gondoskodni szeretne arról, hogy a készlet legalább egy podja egy csomóponton fusson, ehelyett egy DaemonSetet kell használnia.

Démonkészletek

Adott naplógyűjtéshez vagy monitorozáshoz előfordulhat, hogy podot kell futtatnia az összes csomóponton vagy egy kiválasztott csomópontkészleten. A DaemonSets használatával üzembe helyezhet egy vagy több azonos podot. A Démonkészlet-vezérlő biztosítja, hogy minden megadott csomópont a pod egy példányát futtassa.

A DaemonSet-vezérlő a fürtindítási folyamat korai szakaszában ütemezheti a csomópontokon lévő podokat az alapértelmezett Kubernetes-ütemező elindítása előtt. Ez a képesség biztosítja, hogy a DaemonSetben lévő podok az üzembe helyezés vagy a StatefulSet hagyományos podjának ütemezése előtt kezdődnek.

A StatefulSetshez hasonlóan a DaemonSet is egy YAML-definíció részeként van definiálva a használatával kind: DaemonSet.

További információ: Kubernetes DaemonSets.

Feljegyzés

A Virtuális csomópontok bővítmény használata esetén a DaemonSets nem hoz létre podokat a virtuális csomóponton.

Névterek

A Kubernetes-erőforrások, például a podok és az üzemelő példányok logikailag egy névtérbe vannak csoportosítva az AKS-fürtök felosztásához, valamint az erőforrásokhoz való hozzáférés létrehozásához, megtekintéséhez vagy kezeléséhez. Létrehozhat például névtereket az üzleti csoportok elkülönítéséhez. A felhasználók csak a hozzájuk rendelt névtereken belüli erőforrásokat használhatják.

Kubernetes namespaces to logically divide resources and applications

AKS-fürt létrehozásakor a következő névterek érhetők el:

Névtér Leírás
alapértelmezett Ahol a podok és az üzemelő példányok alapértelmezés szerint létrejönnek, ha nincs megadva. Kisebb környezetekben az alkalmazásokat közvetlenül az alapértelmezett névtérbe helyezheti üzembe további logikai elkülönítések létrehozása nélkül. Ha a Kubernetes API-val (például a kubernetes API-val kubectl get pods) kommunikál, a rendszer az alapértelmezett névteret használja, ha nincs megadva.
kube-system Ahol az alapvető erőforrások léteznek, például olyan hálózati funkciók, mint a DNS és a proxy, vagy a Kubernetes-irányítópult. Ebben a névtérben általában nem helyez üzembe saját alkalmazásokat.
kube-public Általában nem használják, de az erőforrások az egész fürtben láthatók, és bármely felhasználó megtekintheti.

További információ: Kubernetes-névterek.

Következő lépések

Ez a cikk néhány alapvető Kubernetes-összetevőt és azok AKS-fürtökre való alkalmazását ismerteti. Az alapvető Kubernetes- és AKS-fogalmakkal kapcsolatos további információkért tekintse meg az alábbi cikkeket: