A Kubernetes alapfogalmai Azure Kubernetes Service (AKS)

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ére és kezelésére vonatkozó igényünket. Vezető platformként a Kubernetes megbízható ütemezést biztosít a hibatűrő alkalmazások számítási feladataihoz. A Azure Kubernetes Service (AKS) egy felügyelt Kubernetes-ajánlat, amely tovább egyszerűsíti a tárolóalapú alkalmazások üzembe helyezését és felügyeletét.

Ez a cikk a következőket mutatja be:

  • Alapvető Kubernetes-infrastruktúra-összetevők:
    • vezérlősík
    • Csomópontok
    • csomópontkészletek
  • Számítási feladatok erőforrásai:
    • podok
    • Telepítések
    • Készletek
  • Erőforrások csoportosítása névterekbe.

Mi az a Kubernetes?

A Kubernetes egy gyorsan fejlődő platform, amely a tárolóalapú alkalmazásokat, valamint a hozzájuk tartozó hálózati és tárolási összetevőket 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ó API-k robusztus készlete biztosít.

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, hogy az alkalmazásokat az előnyben részesített programozási nyelvvel, operációs rendszerrel, kódtárakkal vagy üzenetkezelő busszal hozza létre. A meglévő folyamatos integrációs és folyamatos kézbesítési (CI/CD) eszközök integrálhatók a Kubernetesszel 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éskoordiná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 feladatainak vezénylését biztosítja.
  • Csomópontok: futtassa az alkalmazás számítási feladatait.

A Kubernetes vezérlősík- és csomópont-összetevői

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 közzététele. Ez az összetevő biztosítja az interakciót a felügyeleti eszközökhöz, például kubectl a Kubernetes-irányítópulthoz.
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 skálázásakor az ütemező határozza meg, hogy mely csomópontok futtathatják a számítási feladatot, és elindítja őket.
kube-controller-manager A Vezérlőkezelő felügyel néhány kisebb vezérlőt, amelyek olyan műveleteket hajtanak végre, mint a podok replikálása és a csomópontműveletek kezelése.

Az AKS egybé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 összetevőket (például magas rendelkezésre állású stb. tárolót ) konfigurálnia 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 Azure Portal 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.

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

A kapcsolódó ajánlott eljárásokért lásd: Ajánlott eljárások a fürtbiztonsághoz és a frissítésekhez az AKS-ben.

Csomópontok és csomópontkészletek

Az alkalmazások és a támogató szolgáltatások futtatásához egy 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örnyezetet futtatja.

Összetevő Leírás
kubelet A Kubernetes-ügynök, amely feldolgozza a vezénylési kéréseket a vezérlősíkról, valamint ütemezi és futtatja a kért tárolókat.
kube-proxy Az egyes csomópontokon 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örnyezet Lehetővé teszi a tárolóalapú alkalmazások további erőforrások, például a virtuális hálózat és a tárolók futtatását és használatát. A Kubernetes 1.19-es vagy újabb verzióját linuxos csomópontkészletekhez 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 kezdődően előzetes verzióban használható a tároló-futtatókörnyezethez, 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 tároló-futtatókörnyezetként a Dockert használják.

Azure-beli virtuális gép és támogatási erőforrások Kubernetes-csomóponthoz

A csomópontokhoz tartozó Azure-beli virtuális gép mérete határozza meg a rendelkezésre álló tárolási CPU-kat, memóriát, méretet és típust (például nagy teljesítményű SSD-t vagy 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ényelhetnek-e. Az igényeknek megfelelően skálázza fel az AKS-fürt csomópontjainak számát.

Az AKS-ben a fürt csomópontjaihoz tartozó virtuálisgép-rendszerkép Ubuntu Linux vagy Windows Server 2019 rendszeren alapul. Amikor AKS-fürtöt hoz létre, vagy kibővíti a csomópontok számát, az Azure platform automatikusan létrehozza és konfigurálja a kért számú virtuális gépet. 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-k számának megfelelően lesz hozzárendelve. További információ: Operációsrendszer-lemez alapértelmezett méretezése.

Ha speciális konfigurációra és vezérlésre van szüksége a Kubernetes-csomópont tároló-futtatókörnyezetében és az operációs rendszeren, üzembe helyezhet egy önkiszolgáló fürtöt az Azure fürt API-szolgáltató használatá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 összes erőforrása és az AKS-ben lefoglalható erőforrások között. Jegyezze meg ezeket az információkat, amikor kéréseket és korlátokat állít be a felhasználó által üzembe helyezett podokhoz.

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 lefoglal erőforrásokat. Ahogy a csomópontok egyre nagyobbak lesznek az erőforrásokban, az erőforrás-foglalás nő a felhasználó által üzembe helyezett podok felügyeletére való nagyobb igény miatt.

Megjegyzés

Az AKS-bővítmények, például a Container Insights (OMS) használata további csomópont-erő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 további funkciók futtatása miatt kevésbé lefoglalható processzorhasználatot okozhat.

    Processzormagok a gazdagépen 1 2 4 8 16 32 64
    Kube-fenntartott (ezredmásodperc) 60 100 140 180 260 420 740
  • Memória
    Az AKS által használt memória két érték összegét tartalmazza.

    1. kubelet Daemon
      A kubelet démon az összes 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 biztosítva, hogy a csomópontnak mindig legalább 750 Mi kiosztható legyen. Ha egy gazdagép a rendelkezésre álló memória küszöbértéke alatt van, az kubelet eseményindító leállítja az egyik futó podot, és szabadít fel memóriát 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

Megjegyzé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.

Memória- és CPU-foglalási szabályok:

  • Tartsa kifogástalan állapotban az ügynökcsomópontokat, beleértve a fürt állapota szempontjából kritikus üzemeltetési rendszer podokat is.
  • A csomópont kevesebb lefoglalható memóriát és processzort jelent, mint ha nem egy Kubernetes-fürt része lenne.

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 lefoglal egy mennyiségű cpu- és memóriaerőforrást.

A kapcsolódó ajánlott eljárásokért lásd: Ajánlott eljárások az AKS alapszintű ütemezőfunkcióihoz.

Csomópontkészletek

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 tartalmazza az ügynökcsomópontokat futtató mögöttes virtuális gépeket.

Megjegyzé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öt az alapértelmezett csomópontkészletre skálázhatja vagy frissítheti. Választhat, hogy skáláz vagy frissít egy adott csomópontkészletet. Frissítési műveletek esetén a tárolók futtatása a csomópontkészlet többi csomópontján van ütemezve, amíg az összes csomópontot sikeresen nem frissítik.

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 és kezelése egy fürthöz az AKS-ben.

Csomópontválasztók

Egy több csomópontkészletet tartalmazó 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 ( például a csomópont operációs rendszerét) határozhat meg, amelyekkel szabályozható, hogy a podok hol legyenek ütemezve.

Az alábbi alapszintű 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ával kapcsolatos további információkért lásd: Ajánlott eljárások az AKS speciális ütemezőfunkcióihoz.

Hüvely

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 esetekben 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-ütemező úgy próbálja teljesíteni a kérést, hogy a podokat úgy ütemezi, hogy egy elérhető erőforrásokkal rendelkező csomóponton fussanak. Megadhatja a maximális erőforráskorlátokat is, hogy egy 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 nem rendelkeznek a Kubernetes magas rendelkezésre állási és redundanciájú funkcióival. Ehelyett a podokat a Kubernetes-vezérlők, például az üzembehelyezési vezérlő helyezik üzembe és kezelik.

Üzemelő példányok é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-ütemező biztosítja, hogy a további podok kifogástalan állapotú csomópontokra legyenek ütemezve, ha a podok vagy csomópontok problémákba ütköznek.

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

  • Adott számú replikát ürít ki és szüntet meg.
  • 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 nem frissül.

Az AKS legtöbb állapot nélküli alkalmazásának 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 újra kifogástalan állapotú csomópontokon, ha az aktuális csomópontjuk problémát tapasztal.

Nem szeretné megszakítani a felügyeleti döntéseket egy frissítési folyamattal, ha az alkalmazásnak minimális számú elérhető példányra van szüksége. 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 replika törölhető vagy ütemezhető legyen. A poderőforrás-korlátokhoz hasonlóan az ajánlott eljárás a podkiszakadási költségvetések meghatározása olyan alkalmazások esetében, amelyeknél a replikák minimális számának mindig jelen kell lennie.

Az üzembe helyezéseket általában a vagy kubectl applya használatával kubectl create hozzák létre és felügyelik. Hozzon létre egy üzembe helyezést egy YAML formátumú jegyzékfájl 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) létrehozandó replikát határoz meg, és a tárolón a 80-at kell megnyitni. Az erőforrás-kérések és -korlátok a cpu-hoz és a memóriához is meg vannak határozva.

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ó Description
.apiVersion Meghatározza 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 Docker Hub.
.spec.replicas Megadja, hogy hány podot kell létrehozni. Ez a fájl három deplicá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, amely lehetővé teszi, 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 Meghatározza 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ó lemezképének 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óhoz szükséges 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 cpu-mennyisé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 cpu-mennyiséget. Ezt a korlátot a kubelet kényszeríti ki.
.spec.spec.resources.limits.memory A maximálisan engedélyezett memóriamennyiséget adja meg. Ezt a korlátot a kubelet kényszeríti ki.

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

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

Csomagkezelés a Helmel

A Helmet gyakran használják a Kubernetes-alkalmazások kezelésére. Erőforrásokat üzembe helyezhet olyan meglévő nyilvános Helm-diagramok létrehozásával és használatával, amelyek az alkalmazáskód és a Kubernetes YAML-jegyzékfájljainak csomagolt verzióját tartalmazzák. A Helm-diagramokat tárolhatja helyileg vagy távoli adattárban, például egy Azure Container Registry Helm-diagramtá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 Shell. Keressen vagy hozzon létre Helm-diagramokat, majd telepítse őket a Kubernetes-fürtön. További információ: Meglévő alkalmazások telepítése a Helmdel az AKS-ben.

StatefulSets és DaemonSets

A Kubernetes Scheduler használatával az üzembehelyezési vezérlő replikákat futtat bármely elérhető erőforrással 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 az alábbi alkalmazásokat igénylő alkalmazásokhoz:

  • Állandó elnevezési konvenció vagy tároló.
  • 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 fenntartja az alkalmazások állapotát az egyes podok életciklusán túl, például a tárolást.
  • 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 az állapot nélküli alkalmazásokra irányul. Az állapotalapú alkalmazásokhoz, például az adatbázis-összetevőkhöz, használhatJa a StatefulSetst. Az üzemelő példányokhoz hasonlóan a StatefulSet is létrehoz és kezel legalább egy azonos podot. A StatefulSet replikái az üzembe helyezés, a skálázá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 újra vannak ütemezve egy StatefulSettel.

Adja meg az alkalmazást YAML formátumban a 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 Azure Files által biztosított állandó tárolóba íródnak. A StatefulSets használatakor a mögöttes állandó tároló akkor is megmarad, ha a StatefulSet törlődik.

További információ: Kubernetes StatefulSets.

A StatefulSet-beli replikák ütemezése és futtatása az AKS-fürt bármely elérhető csomópontja között lehetséges. Ha azt szeretné, hogy a készlet legalább egy podja egy csomóponton fusson, használjon helyette egy DaemonSetet.

Démonkészletek

Adott naplógyűjtéshez vagy monitorozáshoz előfordulhat, hogy podot kell futtatnia az összes vagy kijelölt csomóponton. A DaemonSet üzembe helyezését használhatja egy vagy több azonos podon, de a DaemonSet Controller biztosítja, hogy minden megadott csomópont a pod egy példányát futtassa.

A DaemonSet-vezérlő a fürt rendszerindítási folyamatának korai szakaszában ütemezhet podokat a csomópontokon az alapértelmezett Kubernetes-ütemező elindítása előtt. Ez a képesség biztosítja, hogy a DaemonSet-beli podok még az üzembe helyezés vagy a StatefulSet hagyományos podjának ütemezése előtt elindulnak.

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.

Megjegyzés

Ha a Virtuális csomópontok bővítményt használja, 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 névtérbe vannak csoportosítva az AKS-fürtök felosztásához, valamint az erőforrásokhoz való hozzáférés korlátozá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-névterek az erőforrások és alkalmazások logikai felosztásához

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

Névtér Description
alapértelmezett Ahol a podok és az üzemelő példányok alapértelmezés szerint létrejönnek, ha nincs megadva. Kisebb környezetekben közvetlenül az alapértelmezett névtérben helyezhet üzembe alkalmazásokat további logikai elkülönítések létrehozása nélkül. Amikor a Kubernetes API-val kommunikál, például a-val kubectl get pods, az alapértelmezett névtér lesz használva, ha nincs megadva.
kube-system Az alapvető erőforrások, például a DNS és a proxy hálózati funkciói 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 nincs használatban, de használható arra, hogy az erőforrások a teljes fürtben láthatóak legyenek, é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. A Kubernetes és az AKS alapfogalmaival kapcsolatos további információkért tekintse meg a következő cikkeket: