Kubernetes: Aan de slag
Leer hoe je begint met implementeren en toepassingen in containers beheert.
Een inleiding over containers
Voordat je aan de slag gaat met Kubernetes, is het belangrijk dat je begrijpt hoe containervorming werkt.
Vergelijkbaar met hoe transportbedrijven fysieke containers gebruiken om verschillende soorten ladingen te isoleren voor vervoer in schepen, treinen, vrachtwagens en vliegtuigen, maken ook technologieën voor softwareontwikkeling steeds meer gebruik van het concept containervorming.
Een pakketje software, een zogeheten container, bundelt de code van een toepassing samen met de bijbehorende configuratiebestanden, bibliotheken en afhankelijkheden die zijn vereist om de app te laten uitvoeren. Zo kunnen ontwikkelaars en IT-professionals toepassingen sneller en veiliger maken en implementeren.
Containervorming biedt de voordelen van isolatie, draagbaarheid, flexibiliteit, schaalbaarheid en controle over de volledige levenscyclus van de workflow van een toepassing. Een container, onttrokken aan het hostbesturingssysteem, staat op zich en wordt meer draagbaar; en kan worden uitgevoerd op elk platform en in elke cloud, op een uniforme en consistente manier op elke infrastructuur.
Componenten en concepten van Kubernetes
Het cluster
Op het hoogste niveau is Kubernetes georganiseerd als een cluster virtuele of on-premises machines. Deze machines, zogeheten knooppunten, delen compute-, netwerk- en opslagresources. Elk cluster heeft een hoofdknooppunt dat is verbonden met een of meer werkknooppunten. De werkknooppunten zijn verantwoordelijk voor het uitvoeren van groepen toepassingen en workloads in containers, zogeheten pods. Met het hoofdknooppunt beheer je welke pods worden uitgevoerd op welke werkknooppunten.
Het besturingsvlak
Kubernetes bevat een aantal objecten dat gezamenlijk het besturingsvlak vormt, zodat het hoofdknooppunt kan communiceren met de werkknooppunten - en zodat een persoon kan communiceren met het hoofdknooppunt.
Ontwikkelaars en operators voeren interacties voornamelijk uit via het hoofdknooppunt met behulp van kubectl, een opdrachtregelinterface die op het lokale besturingssysteem wordt geïnstalleerd. Opdrachten die via kubectl worden uitgegeven aan het cluster, worden ontvangen door de kube-apiserver, de Kubernetes-API die zich op het hoofdknooppunt bevindt. De kube-apiserver communiceert vervolgens verzoeken naar de kube-controller-manager in het hoofdknooppunt, dat op zijn beurt verantwoordelijk is voor de verwerking van bewerkingen van werkknooppunten. Opdrachten van het hoofdknooppunt worden ontvangen door de kubelet op de werkknooppunten.
Apps en workloads implementeren
De volgende stap om aan de slag te gaan met Kubernetes is het implementeren van apps en workloads. Het hoofdknooppunt onderhoudt op elk moment de huidige status van het Kubernetes-cluster en de configuratie in de etcd, een opslagdatabase voor sleutelwaarden. Als u pods gaat uitvoeren met uw apps en workloads in containers, beschrijft u een nieuwe gewenste status voor het cluster in de vorm van een YAML-bestand. De kube-controller-manager neemt het YAML-bestand en geeft de kube-scheduler de taak om te beslissen welke werkknooppunten de app of workload moet uitvoeren op basis van vooraf bepaalde beperkingen. In harmonie werkend met de kubelet van elk werkknooppunt, start de kube-scheduler de pods, controleert de status van de machines en is algemeen verantwoordelijk voor het resourcebeheer.
In een Kubernetes-implementatie wordt de gewenste status die je beschrijft de huidige status in de etcd. De vorige status gaat echter niet verloren. Kubernetes ondersteunt terugdraaiacties, doorlopende updates en pauzeren van implementaties. Verder gebruiken implementaties ReplicaSets op de achtergrond om ervoor te zorgen dat het opgegeven aantal identiek geconfigureerde pods worden uitgevoerd. Als een of meer pods mislukken, worden deze vervangen door de ReplicaSet. Kubernetes is zogezegd zelfherstellend.
Kubernetes-omgevingen structureren en beveiligen
Je app of workload is nu geïmplementeerd. Om aan de slag te gaan met Kubernetes, moet je ze nu nog organiseren en bepalen wie of wat er toegang tot heeft. Door een naamruimte te maken, dit is een groeperingsmethode in Kubernetes, kunnen services, pods, controllers en volumes eenvoudig samenwerken terwijl ze zijn geïsoleerd van andere onderdelen van het cluster. Je kunt het Kubernetes-concept van naamruimten ook gebruiken om consistente configuraties toe te passen op resources.
Verder bevat elk werkknooppunt een kube-proxy, die bepaalt hoe verschillende aspecten van het cluster van buitenaf kunnen worden benaderd. Bewaar gevoelige niet-openbare informatie zoals tokens, certificaten en wachtwoorden in geheimen, nog een Kubernetes-object, die tot runtime blijven gecodeerd.
Als laatste geef je op wie welke onderdelen van het cluster kan zien en ermee kan communiceren, en hoe ze interactie met elkaar mogen uitvoeren, met behulp van op rollen gebaseerd toegangsbeheer (RBAC).
Een oplossing voor een volledig beheerd Kubernetes-cluster implementeren
Beheer je gehoste Kubernetes-omgeving met Azure Kubernetes Service (AKS). Implementeer en onderhoud apps in containers zonder ervaring met containerindeling. Richt je resources in en upgrade en schaal ze op aanvraag - zonder je apps offline te halen.
Kubernetes-snelstartgids: binnen 50 dagen aan de slag
Gebruik deze stapsgewijze handleiding om aan de slag te gaan met Kubernetes en doe praktijkervaring op met onderdelen, mogelijkheden en oplossingen van Kubernetes.
Het Kubernetes-leertraject volgen
Andere manieren voor verdere ontwikkeling met Kubernetes
