A Kubernetes alapfogalmai a Azure Kubernetes Service (AKS)

Az alkalmazásfejlesztés továbbra is a tárolóalapú megközelítés felé tart, ami növeli az erőforrások vezénylére és kezelésére vonatkozó igényünket. A Kubernetes vezető platformként megbízható ütemezést biztosít a hibatűrő alkalmazások számítási feladataihoz. 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őt mutat be:

  • A Kubernetes alapvető infrastruktúra-összetevői:
    • 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évterekbe.

Mi az a Kubernetes?

A Kubernetes egy gyorsan fejlődő platform, amely tárolóalapú alkalmazásokat, valamint az ezekhez kapcsolódó hálózat- és tárolási összetevőket kezeli. A Kubernetes az alkalmazás számítási feladataira összpontosít, nem az alapul szolgáló infrastruktúra-összetevőkre. A Kubernetes deklaratív megközelítést biztosít az üzembe helyezéshez, amelyet a felügyeleti műveletekhez szükséges API-k robusztus készlete biztosít.

Modern, hordozható, mikroszolgáltatás-alapú alkalmazásokat építhet ki és futtathat, a Kubernetes használatával pedig vezényelheti és kezelheti az alkalmazás-összetevők rendelkezésre állását. A Kubernetes mind az állapot nélküli, mind az állapotalapú alkalmazásokat támogatja, ahogy a csapatok végighaladnak a mikroszolgáltatás-alapú alkalmazások bevezetésén.

Nyílt platformként a Kubernetes lehetővé teszi, hogy az Ön által előnyben részesített programozási nyelvvel, operációs rendszerrel, kódtárakkal vagy üzenetkezelési buszsal készítse el az alkalmazásokat. A meglévő folyamatos integrációs és folyamatos teljesítési (CI/CD) eszközök integrálhatók a Kubernetesbe a kiadások ütemezése és üzembe helyezése érdekében.

Az AKS egy felügyelt Kubernetes-szolgáltatást biztosít, amely csökkenti az üzembe helyezés összetettségét és az alapvető felügyeleti feladatokat, például a frissítéskoordinációt. Az Azure platform kezeli az AKS-vezérlősíkot, ön pedig csak az alkalmazásokat futtató AKS-csomópontokért fizet. Az AKS a nyílt forráskódú motorra Azure Kubernetes Service: aks-engine.

Kubernetes-fürtarchitektúra

A Kubernetes-fürt két összetevőre oszlik:

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

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

Vezérlősík

AKS-fürt létrehozásakor a rendszer automatikusan létrehoz és konfigurál egy vezérlősíkot. Ez a vezérlősík ingyenes, mivel a felhasználótól absztrakt felügyelt Azure-erőforrás. Csak az AKS-fürthöz csatolt csomópontokért kell fizetnie. A vezérlősík és az erőforrásai csak 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ó teszi elérhetővé az alapul szolgáló Kubernetes API-kat. Ez az összetevő biztosítja az interakciót a felügyeleti eszközökhöz, például a vagy a kubectl Kubernetes-irányítópulthoz.
etcd (stb.) A Kubernetes-fürt és a konfiguráció állapotának fenntartása érdekében a magas rendelkezésre állás stb. kulcsérték-tároló a Kubernetesben.
kube-scheduler Amikor alkalmazásokat hoz létre vagy skáláz, az ütemező meghatározza, hogy mely csomópontok futtathatják a számítási feladatot, és elindítja azokat.
kube-controller-manager A Vezérlőkezelő felügyel néhány kisebb vezérlőt, amelyek olyan műveleteket hajt 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ó Kubernetes API-kon keresztül történik, például vagy a kubectl Kubernetes-irányítópulton keresztül.

Bár ezzel a felügyelt vezérlősíkkal nem kell összetevőket (például magas rendelkezésre álló stb. tárolót) konfigurálnia, a vezérlősíkhoz nem férhet hozzá közvetlenül. A Kubernetes vezérlősík- és csomópontfrissítései az Azure CLI vagy a Azure Portal. A lehetséges problémák elhárításához tekintse át a vezérlősík naplóit a Azure Monitor naplókban.

A vezérlősík konfiguráláshoz vagy közvetlen eléréséhez telepítse a saját Kubernetes-fürtöt az aks-engine használatá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-ban.

Csomópontok és csomópontkészletek

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

Összetevő Leírás
kubelet A kubernetes-ügynök, amely a vezérlősíkról származó vezénylési kérelmeket dolgozza fel, és ütemezi a kért tárolók futtatását.
kube-proxy Minden csomóponton kezeli a virtuális hálózatokat. A proxy irányítja a hálózati forgalmat, és kezeli a szolgáltatások és podok IP-címzését.
tároló-futtatás Lehetővé teszi, hogy a tárolóba telepített alkalmazások további erőforrásokat futtassanak és használjanak, például a virtuális hálózatot és a tárolót. A Linux-csomópontkészletek esetén a Kubernetes 1.19-es vagy újabb verzióját használó AKS-fürtök containerd tároló-futtatásként használhatók. A Kubernetes Windows-csomópontkészletekhez való 1.20-as verziójától kezdve előzetes verzióban használható a tároló-futtatás, de továbbra is a Docker az alapértelmezett containerd tároló-futtatás. A Csomópontkészletek esetén a Kubernetes korábbi verzióit használó AKS-fürtök a Docker-t használják tároló-futtatásként.

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

A csomópontok Azure-beli virtuális gépének mérete határozza meg az elérhető tárolási PROCESSZORokat, memóriát, méretet és típust (például nagy teljesítményű SSD vagy normál HDD). Tervezze meg a csomópont méretét úgy, 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ázja fel horizontálisan az AKS-fürt csomópontjainak számát az igényeknek megfelelően.

Az AKS-ben a fürt csomópontjainak virtuálisgép-rendszerképe Ubuntu Linux Server 2019-Windows alapul. Amikor létrehoz egy AKS-fürtöt, vagy horizontálisan felskálái a csomópontok számát, az Azure platform automatikusan létrehozza és konfigurálja a virtuális gépek kért számát. Az ügynökcsomópontok számlázása standard virtuális gépként történik, így a virtuális gépek méretére vonatkozó kedvezmények (az Azure Reservationstis beleértve) automatikusan alkalmazva vannak.

Saját Kubernetes-fürt üzembe helyezése az aks-engine használatával, ha más gazda operációs rendszert, tároló-futásidőt vagy különböző egyéni csomagokat használ. A upstream kiadja a szolgáltatásokat, és az AKS-fürtök támogatása előtt konfigurációs aks-engine lehetőségeket biztosít. Ha tehát a vagy a Dockertől különböző tároló-futtatókörnyezetet szeretne használni, a futtatásával konfigurálhatja és üzembe helyezheti az aktuális igényeinek megfelelő containerd aks-engine Kubernetes-fürtöt.

Erőforrás-foglalások

Az AKS csomópont-erőforrások segítségével segít a csomópontnak a fürt részeként működni. Ez a használat eltérést okozhat a csomópont összes erőforrása és az AKS-hez elérhető erőforrások között. Ne feledje ezt az információt, amikor kéréseket és korlátokat ad meg a felhasználó által üzembe helyezett podok számára.

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

kubectl describe node [NODE_NAME]

A csomópontok teljesítményének és funkcióinak fenntartása érdekében az AKS minden csomóponton lefoglalja az erőforrásokat. A csomópontok erőforrásokban való növekedésével az erőforrás-foglalás is nő, mivel a felhasználó által üzembe helyezett podok felügyeletének magasabb szintűre van szüksége.

Megjegyzés

Az AKS-bővítmények, például a Container Elemzések (OMS) további csomópont-erőforrásokat használnak fel.

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

  • CPU
    A fenntartott CPU a csomópont típusától és a fürtkonfigurációtól függ, ami a további funkciók futtatása miatt kevésbé lefoglalható processzort okozhat.

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

    1. kubelet Daemon
      A démon az összes Kubernetes-ügynökcsomóponton telepítve van a tárolók létrehozásának kubelet és megszüntetésének kezeléséhez.

      Alapértelmezés szerint az AKS-ben a démon rendelkezik a memory.available értékekkel<750Mi kilakoltatási szabály, amely biztosítja, hogy a csomópontok mindig legalább kubelet 750 Mi allokálható legyen. Ha egy gazdagép a rendelkezésre álló memória küszöbértéke alatt van, az eseményindító megszakítja az egyik futó podot, és memóriát szabadít fel a kubelet gazdagépen.

    2. A kubelet-démon memóriafoglalásának regressziós 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

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

  • Az ügynökcsomópontok kifogástalan állapotban maradnak, beleértve a fürt állapotához kritikus fontosságú üzemeltetési rendszerpodokat is.
  • Ha azt szeretné, hogy a csomópont kevesebb foglalható memóriát és processzort jelentsen, mint ha nem egy Kubernetes-fürt tagja 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 foglalhatja le, beleértve a 750Mi hard eviction küszöbértéket.

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

Magának a Kubernetesnek a foglalásai mellett a mögöttes csomópont operációs rendszer is lefoglal egy mennyiségű cpu- és memória-erőforrást az operációs rendszer funkcióinak fenntartásához.

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

Csomópontkészletek

Az azonos konfigurációban lévő csomópontok csomópontkészletekbe vannak csoportosítva. A Kubernetes-fürt legalább egy csomópontkészletet tartalmaz. A csomópontok kezdeti számát és méretét az AKS-fürt létrehozásakor kell meghatározni, 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éhez legalább két (2) csomópontot kell futtatnia az alapértelmezett csomópontkészletben.

Az AKS-fürtök az alapértelmezett csomópontkészletre skálázva vagy frissítve vannak. 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 meg nem történik.

További információ több csomópontkészlet AKS-ben való használatával kapcsolatban: Több csomópontkészlet létrehozása és kezelése egy fürthöz az AKS-ban.

Csomópontválasztók

Egy több csomópontkészlettel rendelkező AKS-fürtben előfordulhat, hogy meg kell mondania a Kubernetes Schedulernek, hogy melyik csomópontkészletet használja egy adott erőforráshoz. A bejövő vezérlők például nem futnak a Windows csomópontokon.

A csomópontválasztókkal különböző paramétereket határozhat meg, például a csomópont operációs rendszerét, amelyek a podok ütemezési helyének szabályozását határozzák meg.

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ési helyének szabályozásával kapcsolatos további információkért tekintse meg az AKS speciális ütemezői funkcióinak ajánlott eljárásait.

Hüvely

A Kubernetes podok segítségével futtatja az alkalmazás egy példányát. A podok az alkalmazás egyetlen példányát képviselik.

A podok általában egy az egyhez típusú leképezést tartalmaznak egy tárolóval. Speciális forgatókönyvekben 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 bizonyos mennyiségű CPU- vagy memória-erőforrás igénylésére vonatkozó erőforráskéréseket. A Kubernetes Scheduler úgy próbálja teljesíteni a kérést, hogy úgy ütemezi a podokat, hogy a rendelkezésre álló erőforrásokkal egy csomóponton fussnak. Maximális erőforráskorlátokat is megadhat, hogy a podok ne fogyasztanak túl sok számítási erőforrást a mögöttes csomópontról. Az ajánlott eljárás az összes pod erőforráskorlátának alkalmazása, hogy a Kubernetes Scheduler azonosítsa a szükséges és engedélyezett erőforrásokat.

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

A podok logikai erőforrások, de az alkalmazás számítási feladatai a tárolókon futnak. A podok általában aknázható, egyszeres erőforrások. Az egyénileg ütemezett podok nem tákolnak el a magas rendelkezésre állás és a redundancia Kubernetes-funkcióinak egy része. Ehelyett a podokat a Kubernetes-vezérlők telepítik és kezelik, például az üzembe helyezési vezérlő.

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

Az üzemelő példányok azonos podokat képviselnek, amelyek a Kubernetes üzembe helyezési vezérlője által vannak kezeltek. Az üzemelő példány határozza meg a létrehozható podreplikák számát. A Kubernetes Scheduler biztosítja, hogy további podok ütemezve vannak a kifogástalan állapotú csomópontokon, ha a podok vagy csomópontok problémákba ütköznek.

Az üzemelő példányok frissítéséhez módosíthatja a podok, a használt tároló-rendszerkép vagy a csatlakoztatott tároló konfigurációját. Az üzembe helyezési vezérlő:

  • Adott számú replikát ürít ki és szüntet meg.
  • Replikákat hoz létre az új üzembe helyezési definícióból.
  • A folyamat addig folytatódik, amíg az üzemelő példány összes replikája nem frissül.

Az AKS-ben a legtöbb állapot nélküli alkalmazásnak az üzembe helyezési modellt kell használnia az egyes podok ütemezése helyett. A Kubernetes figyelheti az üzembe helyezés állapotát, így biztosíthatja, 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ába ütköznek, és nem ütemezik át őket kifogástalan állapotú csomópontokon, ha az aktuális csomópontjuk problémába ütközik.

Nem szeretné megzavarni a felügyeleti döntéseket egy frissítési folyamattal, ha az alkalmazásnak minimális számú rendelkezésre álló példányra van szüksége. A podkimaradási költségvetések határozzák meg, hogy egy üzemelő példányban hány replika ható le a frissítés vagy a csomópont frissítése során. Ha például öt (5) replika van az üzemelő példányban, meghatározhat egy 4 (négy) megszakítású podot, hogy egyszerre csak egy replika legyen törölve vagy ütemezve. Ahogy a podok erőforráskorlátai esetében, az ajánlott eljárás a podkimaradások költségvetésének meghatározása olyan alkalmazások esetében, amelyek minimális számú replikát igényelnek, hogy mindig jelen legyen.

Az üzemelő példányok általában a vagy a alkalmazással vannak kubectl create létrehozva és kubectl apply kezelhetők. Hozzon létre egy üzemelő példányot YAML formátumban definiáló jegyzékfájllal.

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étrehozható replikát ad meg, és megköveteli, hogy a 80-as port nyitva legyen a tárolón. 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

Összetettebb alkalmazásokat úgy is létre lehet hoznunk, hogy szolgáltatásokat (például terheléselosztásokat) is beleveszünk a YAML-jegyzékbe.

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

Csomagkezelés a Helmmal

A Helmet gyakran használják alkalmazások kezelésére a Kubernetesben. Az erőforrások üzembe helyezéséhez olyan meglévő nyilvános Helm-diagramokat kell építenie és használnia, 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-diagramtárban.

A Helm használata előtt telepítse a Helm-ügyfelet a számítógépre, vagy használja a Helm-ügyfelet a Azure Cloud Shell. Keresse meg vagy hozza létre a Helm-diagramokat, majd telepítse őket a Kubernetes-fürtön. További információ: Meglévő alkalmazások telepítése a Helm-sel az AKS-ban.

StatefulSets és DaemonSets

A Kubernetes Scheduler használatával a központi telepítési vezérlő minden elérhető csomóponton futtat replikákat az elérhető erőforrásokkal. Bár ez a megközelítés elegendő lehet az állapot nélküli alkalmazásokhoz, a Deployment Controller nem ideális az olyan alkalmazásokhoz, amelyek a következőt igénylik:

  • Állandó elnevezési konvenció vagy tároló.
  • Egy replika, amely a fürt minden egyes csomópontján létezni fog.

Két Kubernetes-erőforrás azonban az alábbi típusú alkalmazásokat kezeli:

  • A StatefulSets az alkalmazások állapotát az egyes pod-életciklusok, például a tárterületen túl is fenntartja.
  • A daemonSets biztosítja, hogy minden csomóponton fut egy futó példány 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 állapot-állapot- és adatbázis-összetevőket is magukban foglaló alkalmazásokhoz használhatja a StatefulSets et. Az üzemelő példányokhoz hasonló módon 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építés elegáns, szekvenciális megközelítését követik. Az elnevezési konvenciók, a hálózatnevek és a tárterület akkor is megmaradnak, ha a replikákat a StatefulSet újraütemezi.

Definiálja az alkalmazást YAML formátumban a kind: StatefulSet használatával. Innen a StatefulSet Controller kezeli a szükséges replikák üzembe helyezését és kezelését. Az adatok állandó tárolóba vannak írva, amelyet az Azure Managed Disks vagy Azure Files. A StatefulSets esetén a mögöttes állandó tároló akkor is megmarad, ha törlik a StatefulSetet.

További információ: Kubernetes StatefulSets.

A StatefulSetben lévő replikák ütemezve vannak, és az AKS-fürt bármely elérhető csomópontján futnak. Annak érdekében, hogy a készletben legalább egy pod egy csomóponton futjon, használjon inkább egy DaemonSetet.

DaemonSets (Démonkészletek)

Adott naplógyűjtéshez vagy monitorozáshoz szükség lehet egy pod futtatására az összes vagy kijelölt csomóponton. A DaemonSet üzembe helyezést egy vagy több azonos podon is használhatja, de a DaemonSet Controller biztosítja, hogy minden megadott csomópont a pod egy példányát futtasa.

A DaemonSet Controller képes podokat ütemezni a csomópontokon a fürt rendszerindítási folyamatának korai szakaszában, még az alapértelmezett Kubernetes-ütemező elindulása előtt. Ez a képesség biztosítja, hogy a DaemonSetben a podok a hagyományos podok előtt elindulnak az üzemelő példányban vagy a StatefulSetben.

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

További információ: Kubernetes DaemonSets.

Megjegyzés

Ha a Virtuális csomópontok bővítménythaszná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 egy névtérbe vannak csoportosítva az AKS-fürt felosztása és az erőforrásokhoz való hozzáférés korlátozása érdekében. Létrehozhat például névtereket az üzleti csoportok külön-külön való létrehozásához. A felhasználók csak a hozzárendelt névterük erőforrásaival kommunikálhatnak.

Kubernetes-névterek az erőforrások és alkalmazások logikai felosztása érdekében

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 megjelölve. Kisebb környezetekben az alkalmazásokat közvetlenül az alapértelmezett névtérben helyezheti üzembe anélkül, hogy további logikai elkülönítéseket hoz létre. A Kubernetes API,például a és a használata esetén a rendszer az alapértelmezett névteret használja, kubectl get pods ha nincs megadva.
kube-system Az alapvető erőforrások, például a hálózati funkciók, például a DNS és a proxy, vagy a Kubernetes-irányítópult. Ebben a névtérben általában nem helyezhet üzembe saját alkalmazásokat.
kube-public Általában nem használatos, de használható arra, hogy az erőforrások a teljes fürtben láthatók legyenek, és bármely felhasználó megtekintheti őket.

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 tartalmazza. A Kubernetes és az AKS alapvető fogalmairól a következő cikkekben talál további információt: