A Kubernetes alapfogalmai Azure Kubernetes Service (AKS)

  • Cikk
  • 13 perc alatt elolvasható

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 processzorokat, a memóriát, a méretet és az elérhető tároló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 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 szabmával, így biztosítva, hogy a csomópontok mindig legalább 750 Mi kiosztható értékkel rendelkezzenek. Ha egy gazdagép a rendelkezésre álló memória küszöbértéke alatt van, a 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

Megjegyzés

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

Memória- és PROCESSZORkiosztási szabályok:

  • Az ügynökcsomópontok kifogástalan állapotának megőrzése, beleértve a fürt állapota szempontjából kritikus fontosságú ü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, akkor 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ória-erő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. Dönthet úgy, hogy skáláz vagy frissít egy adott csomópontkészletet. Frissítési műveletek esetén a futó tárolók a csomópontkészlet más csomópontjaira vannak ütemezve, amíg az összes csomópont frissítése sikeresen le nem zárul.

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

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 definiálhat, például a csomópont operációs rendszerét, amelyekkel 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ó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ési helyére vonatkozó 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 meghatározhat erőforrás-kérelmeket bizonyos mennyiségű CPU- vagy memória-erőforrás lekéréséhez. A Kubernetes Scheduler úgy próbálja teljesíteni a kérést, hogy ütemezi a podok futtatását egy elérhető erőforrásokkal rendelkező csomóponton. 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ópontról. Az ajánlott eljárás az, hogy minden pod erőforráskorlátait 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ő kezel. Az üzembe helyezés határozza meg a létrehozandó podreplikák számát. A Kubernetes Scheduler biztosítja, hogy további podok legyenek ütemezve kifogástalan állapotú csomópontokon, ha a podok vagy csomópontok problémákba ütköznek.

Az üzemelő példányok frissítésével módosíthatja a podok, a használt tárolólemezképek vagy a csatolt tárolók konfigurációját. 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 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ürtön belül. 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ába ütközik.

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 replika törölhető vagy ütemezhető legyen. A poderőforrás-korlátokhoz hasonlóan az ajánlott eljárás a podkimaradá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 üzemelő példányokat általában a vagy kubectl applya használatával hozzák létre és kezelikkubectl create. 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) replikát határoz meg, és megköveteli, hogy a 80-ás port nyitva legyen a tárolón. Az erőforrás-kérelmek és -korlátok a processzor és a memória esetében 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 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 üzemelő példány nevét. Ez a fájl a Docker Hub nginx-rendszerképét fogja futtatni.
.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 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 elérhetővé tenni kívánt portok listáját.
.spec.spec.containers.ports.containerPort Megadja a pod IP-címén elérhetővé tenni kívánt 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 érvényesíti.
.spec.spec.resources.limits.cpu Megadja a maximálisan engedélyezett cpu-mennyiséget. Ezt a korlátot a kubelet érvényesíti.
.spec.spec.resources.limits.memory Megadja az engedélyezett memória maximális mennyiségét. Ezt a korlátot a kubelet érvényesíti.

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

További információ: Kubernetes-üzemelő példányok.

Csomagkezelés a Helmrel

A Helmt gyakran használják alkalmazások kezelésére a Kubernetesben. Az erőforrásokat 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ékfájljainak 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 Shell. Keressen vagy hozzon létre Helm-diagramokat, majd telepítse őket a Kubernetes-fürtre. További információ: Meglévő alkalmazások telepítése a Helmrel 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ásokkal rendelkező elérhető 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 azokhoz az alkalmazásokhoz, amelyekhez a következők szükségesek:

  • Állandó elnevezési konvenciók vagy tárolók.
  • 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 Démonkészletek biztosítják a futó példányt minden csomóponton, 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 ü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 skálázás, a frissítés és a leállítás kecses, 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.

Definiálja 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 esetén a mögöttes á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 meg szeretné győződni arról, hogy a készlet legalább egy podja egy csomóponton fut, 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 vagy kijelölt csomóponton. A DaemonSet üzembe helyezését használhatja egy vagy több azonos podon, de a DaemonSet-vezérlő biztosítja, hogy minden megadott csomópont a pod egy példányát futtassa.

A Démonkészlet-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 DaemonSetben lévő podok a központi telepítésben vagy a StatefulSetben lévő hagyományos podok ütemezése előtt indulnak el.

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

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 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 megosztá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 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 következővel 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 a teljes 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. A Kubernetes és az AKS alapfogalmaival kapcsolatos további információkért tekintse meg az alábbi cikkeket: