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.
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. |
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.kubelet
Daemon
Akubelet
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, akubelet
eseményindító leállítja az egyik futó podot, és memóriát szabadít fel a gazdagépen.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 apply
a 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.
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: