‫Vanwege de enorme flexibiliteit die we hebben met
‫Kubernetes, zijn er veel stijlen voor hoe u
‫uw werk doet in het Kubernetes-clustersysteem.
‫Je hebt me daar al eerder over horen praten, toch.
‫Ik heb je verteld dat er verschillende manieren zijn om in je
‫workflow te passen en dat je verschillende commando's op
‫verschillende manieren kunt gebruiken. Dus dat kan een uitdaging zijn
‫als je het probeert te onderwijzen, omdat mensen echt willen weten hoe
‫ze het zouden moeten gebruiken. Zoals wat is de beste manier?
‫Wat is de beste praktijk? Dat is moeilijk, want het hangt
‫er echt van af wat je eruit wilt halen.
‫Het is het, het is een onaantrekkelijk gedateerd systeem.
‫Er zijn dus veel verschillende manieren om dingen te doen.
‫Hier probeer ik dat te doorbreken.
‫Deze is dus een belangrijke.
‫Maar dit is allemaal gewoon leren op een dia.
‫Dit ben ik die een paar minuten tegen je praat om
‫te proberen deze concepten op te splitsen en toe te passen wat
‫ze specifiek voor Kubernetes betekenen.
‫Voordat we bij de aanbevolen benaderingen komen, zullen er
‫in feite drie aanbevolen strategieën zijn voor
‫het gebruik van Kubernetes.
‫Hier moet ik enkele van deze termen
‫opsplitsen, zodat je weet wat die volgende lezing is.
‫Je zult dit in veel blogposts en
‫in documentatie zien. Dwingend versus declaratief.
‫De beste manier om het te beschrijven, in relatie tot Kubernetes, is om een
‫back-up te maken en gewoon te zeggen wat het
‫betekent in termen van software.
‫Wanneer we verplicht software schrijven, zijn we gefocust
‫op het hoe van dat programma, elke stap, in
‫volgorde, de een na de ander.
‫Als we het hebben over een declaratieve benadering van
‫software, beschrijven we meer over wat het zou moeten bereiken.
‫Wat zijn zijn einddoelen?
‫Het maakt ons niet zoveel uit hoe het daar komt, alleen
‫dat het er komt. Laten we een analogie proberen.
‫Stel je voor dat je een kopje koffie wilt.
‫Als ik elke ochtend wakker word, ben ik op zoek
‫naar dat eerste kopje. Als ik het zelf wil
‫maken, zal ik het absoluut moeten doen.
‫Ik moet eraan denken om wat water te koken.
‫Wat is de volgende stap? Ik heb wat koffiebonen nodig.
‫Dan moet ik die bonen malen. Hoeveel heb
‫ik precies nodig? Hoeveel water moet ik over
‫die bonen gieten om de perfecte kop koffie enz. te krijgen.
‫Ik doorloop elke stap en denk stap voor stap na
‫over hoe het moet.
‫Dat is noodzakelijk. Als je naar Kubernetes kijkt, zullen we
‫het daar zo over hebben.
‫Declaratieve modus. Zie het meer alsof ik
‫in een coffeeshop ben en met een barista praat.
‫Ik vraag het ze gewoon.
‫Ik wil graag een kopje koffie.
‫Mijn enige taak is om de kop koffie
‫te vragen en het is aan hen om erachter te komen, hé.
‫Moet ik het helemaal opnieuw maken? Zit er al een in
‫de pot? Of is de pot te oud?
‫Ze kunnen doen... ze kunnen... misschien drie keer opnieuw
‫moeten proberen om de kop koffie te zetten omdat ze
‫het verknoeid hebben. Dat is prima.
‫Ik vraag niet hoe ze het maken.
‫Ik vraag of ze een kopje koffie voor me willen maken.
‫Laten we dit toepassen op de opdrachten die u
‫in Kubernetes gaat gebruiken. Laten we ons concentreren op imperatief,
‫wat je tot nu toe grotendeels hebt geleerd, omdat het de
‫manier is om te beginnen met het leren van een tool die
‫absoluut noodzakelijk is. Je gaat deze dingen
‫doen in de volgorde waarin ze moeten worden gedaan, en je
‫geeft het expliciete instructies over hoe het moet.
‫Deze opdrachten, zoals kubectl, worden uitgevoerd en maken
‫implementatie en update, die we nog niet hebben behandeld, of bewerken.
‫Dit zijn de verschillende soorten
‫opdrachten waarmee u begint in een staat die u kent.
‫Wanneer u de opdracht Create Deployment gebruikt,
‫weet u dat de implementatie nog niet is gemaakt.
‫Je gebruikt dus de create, toch.
‫Als je iets wilt bijwerken of bewerken, gebruik je dat commando
‫expliciet om dat te doen.
‫Het leuke hier voor de opdrachtregel en het typen in de
‫CLI is dat verschillende opdrachten worden gebruikt voor verschillende soorten acties, of
‫het nu gaat om maken, bijwerken of verwijderen.
‫Dat is gemakkelijker voor onze hersenen om te onthouden, omdat we
‫weten welke actie we ondernemen.
‫Onthoud dat imperatief gemakkelijker is als u de
‫staat van het object of de resource al kent en
‫u net begint met het gebruik van de tools.
‫Dus je wilt expliciet denken, oké, ik moet een service maken
‫en die service moet een load balancer zijn.
‫Je kent dat soort dingen. Dan is het voor ons in
‫onze menselijke geest gemakkelijker om deze dingen in de CLI te typen.
‫Het is helaas niet eenvoudig
‫te automatiseren. Dat is een van de
‫grootste nadelen van dit soort werk, dat het erg
‫moeilijk is om een geautomatiseerd script of tool te krijgen om
‫automatisch de, oh is dit een update die je wilt,
‫af te handelen? Of is dit een creatie?
‫Of is dit een verwijdering? Zoals je weet,
‫wat moet ik hier doen? Het is voor ons moeilijk om dat
‫soort werk te automatiseren. In ons hoofd is het makkelijk.
‫Makkelijk voor ons om te typen bij de CLI. Voor ons moeilijk te automatiseren.
‫Onthoud dat declaratief betekent dat we de staat niet echt kennen.
‫Denk aan de koffie. Ik weet niet of ze koffie
‫hebben of niet. Misschien hebben ze er al een paar gemaakt. Misschien moeten ze
‫er een aantal helemaal opnieuw maken.
‫Ik ken de staat niet.
‫Ik weet gewoon het eindresultaat dat ik wil.
‫Dat is echt passend voor een declaratief model.
‫Enkele van de voordelen hier voor ons, en
‫voor automatisering, zijn dat hetzelfde commando, meestal ga
‫je het toepassen commando, kubectl toepassen.
‫Diezelfde opdracht kan worden gebruikt, ongeacht
‫of we bronnen maken, bijwerken of
‫zelfs verwijderen. Als je naar YAML gaat kijken, waar
‫we zo meteen op ingaan.
‫Die YAML kan ofwel in een enkel bestand zijn.
‫U kunt veel verschillende soorten bronnen bundelen
‫in één YAML. Of u kunt ze opsplitsen in
‫een enkel object in elk YAML-bestand in een enkele map, en u kunt
‫één opdracht gebruiken om de hele map toe te passen.
‫Er zijn veel opties daar.
‫De redenen waarom we niet aan de slag gaan met deze methode,
‫is dat we die niet altijd nodig hebben.
‫Het voegt een beetje complexiteit toe omdat je dit bestand,
‫en alle dingen erin, moet maken voordat je het zelfs
‫maar kunt doen.
‫Je hebt die misschien niet helemaal opnieuw, en je wilt
‫ze niet per se maken om een
‫pod of zoiets te maken, toch. Dus, om te beginnen, de CLI is logisch.
‫Het gebruik van de standaard imperatieve commando's is logisch.
‫Maar als je begint na te denken over productie
‫en automatisering, en dit herhalende updateproces keer op keer doet,
‫zoals je gaat doen, dan begin je na
‫te denken over, oké. Ik heb een meer declaratieve benadering nodig.
‫De uitdaging daar is dat je al die YAML-sleutels en
‫-instellingen moet kennen, en je moet gewoon helemaal opnieuw beginnen en
‫je expertise in de loop van de tijd opbouwen in alle manieren en dingen
‫die je in deze YAML moet stoppen.
‫Het mooie is dat uw investering niet
‫voor niets is. Terwijl je nu een
‫aantal basisdingen in Kubernetes gedaan krijgt door de CLI's
‫zoals kubectl run of create te typen.
‫Gedurende die tijd kijk je naar YAML met het
‫uitvoercommando, onthoud de -o yaml.
‫U kunt de uitvoer van de YAML bekijken.
‫Er zijn andere manieren waarop we naar YAML kunnen kijken.
‫We beginnen onze kennis op te bouwen over hoe die YAML
‫eruit zou moeten zien, zodat als je eenmaal in de wereld bent in
‫productie waar je in feite de hele dag YAML aan het doen bent,
‫je een beetje meer vertrouwd zult raken met de manier waarop
‫het is uitgebroken. Deze YAML-manier
‫is de gemakkelijkste manier om uw orkestratie te automatiseren.
‫Dit is ook de gemakkelijkste manier om geluk
‫te krijgen. We zullen niet veel
‫praten over get-ops in deze cursus. Ik raad je
‫aan om naar Google te gaan, omdat het
‫een soort DevOps-werk is dat de get-tool gebruikt
‫als je bron van waarheid.
‫Kortom, elke keer dat u een wijziging in uw omgeving
‫wilt aanbrengen, bewerkt u wat YAML.
‫Je voert het commando Apply uit.
‫Je doet een get-commit. Nu heb je dit get-log
‫van alles wat je hebt gedaan. Dat is een
‫van de kenmerken van het get-ops-bewerkingsmodel en dit met
‫declaratief doen, is hoe je daar komt.
‫Laten we eens kijken naar de drie manieren waarop de Kubernetes-teams
‫denken dat we de Kubernetes-opdrachtregel zouden moeten gebruiken.