Kuberneteslijkt te gaan over het implementeren van containers in een wolk van clusters. Wat het niet lijkt te raken, zijn ontwikkel- en staging-omgevingen (of dergelijke).

Tijdens de ontwikkeling wil je zo dicht mogelijk bij de productieomgeving zijn met enkele belangrijke wijzigingen:

• Lokaal geïmplementeerd (of in ieder geval ergens waar u en alleen u toegang hebben)
• Gebruik nieuwste broncodebij het vernieuwen van de pagina (ervan uitgaande dat het een website is; idealiter wordt de pagina automatisch vernieuwd bij het opslaan van lokale bestanden, wat kan worden gedaan als u de broncode koppelt en wat dingen gebruikt zoals Yeoman).

Op dezelfde manier kan men willen dat een niet-openbare omgeving continue integratiedoet.

Ondersteunt Kubernetes zo’n ontwikkelomgeving of is het iets dat je moet bouwen, in de hoop dat het tijdens de productie nog steeds werkt?

Antwoord 1, autoriteit 100%

Update (2016-07-15)

Met de release van Kubernetes 1.3 is Minikubenu de aanbevolen manier om Kubernetes op uw lokale machine uit te voeren voor ontwikkeling.

Je kunt Kubernetes lokaal uitvoeren via Docker. Als je eenmaal een node hebt uitgevoerd, kun je een pod starten die een eenvoudige webserver heeft en een volume vanaf je hostmachine koppelt. Wanneer u de webserver bereikt, leest deze van het volume en als u het bestand op uw lokale schijf hebt gewijzigd, kan het de nieuwste versie weergeven.

Antwoord 2, autoriteit 13%

We hebben aan een tool gewerkt om dit te doen. Het basisidee is dat je een extern Kubernetes-cluster hebt, in feite een staging-omgeving, en dan voer je de code lokaal uit en wordt het via een proxy naar het externe cluster gestuurd. U krijgt transparante netwerktoegang, gekopieerde omgevingsvariabelen, toegang tot volumes… zo dicht mogelijk bij de externe omgeving, maar met uw code lokaal en onder uw volledige controle.

Dus je kunt bijvoorbeeld live-ontwikkeling doen. Documenten op http://telepresence.io

Antwoord 3, autoriteit 7%

Het soort “hot reload” is iets dat we van plan zijn toe te voegen, maar het is niet zo eenvoudig als het nu zou kunnen zijn. Als je echter avontuurlijk bent ingesteld, kun je rsync gebruiken met docker exec, kubectl exec of osc exec (ze doen allemaal ongeveer hetzelfde) om een ​​lokale map in een container te synchroniseren wanneer deze verandert. Je kunt rsync gebruiken met kubectl of osc exec als volgt:

# rsync using osc as netcat
$ rsync -av -e 'osc exec -ip test -- /bin/bash' mylocalfolder/ /tmp/remote/folder

Antwoord 4, autoriteit 7%

Een ander goed startpunt is deze Vagrant setup, in het bijzonder. als uw host-besturingssysteem Windows is. De voor de hand liggende voordelen zijn

• snelle en pijnloze installatie
• gemakkelijk om de machine te vernietigen / opnieuw te maken
• impliciete limiet op middelen
• mogelijkheid om horizontale schaling te testen door meerdere knooppunten te maken

De nadelen – je hebt veel RAM nodig, en VirtualBox is VirtualBox… voor beter of slechter.

Een gemengd voordeel/nadeel is het toewijzen van bestanden via NFS. In onze opzet hebben we twee sets RC-definities gemaakt – een die alleen een docker-image van onze applicatieservers downloadt; de andere met 7 extra regels die bestandstoewijzing instellen vanuit HostOS -> Zwerver -> VirtualBox -> CoreOS -> Kubernetes-pod; de broncode van de Docker-afbeelding overschrijven.

Het nadeel hiervan is de cache van NFS-bestanden – daarmee is het problematisch, zonder is het problematisch traag. Zelfs het instellen van mount_options: 'nolock,vers=3,udp,noac'lost cachingproblemen niet volledig op, maar het werkt meestal wel. Sommige Gulp-taken die in een container worden uitgevoerd, kunnen 5 minuten duren terwijl ze 8 seconden duren op het host-besturingssysteem. Een goed compromis lijkt mount_options: 'nolock,vers=3,udp,ac,hard,noatime,nodiratime,acregmin=2,acdirmin=5,acregmax=15,acdirmax=15'.

Wat betreft het automatisch opnieuw laden van code, dat is taalspecifiek, maar we zijn blij met Django’s devserver voor Python en Nodemon voor Node.js. Voor frontend-projecten kun je natuurlijk veel doen met zoiets als gulp+browserSync+watch, maar voor veel ontwikkelaars is het niet moeilijk om vanuit Apache te bedienen en gewoon traditionele harde refresh te doen.

We bewaren 4 sets yaml-bestanden voor Kubernetes. Dev, “devstable”, podium, prod. De verschillen daartussen zijn

• env-variabelen die expliciet de omgeving instellen (dev/stage/prod)
• aantal replica’s
• devstable, stage, prod gebruikt docker-afbeeldingen
• dev gebruikt docker-afbeeldingen en wijst de NFS-map toe met de broncode eroverheen.

Het is erg handig om veel bash-aliassen te maken en automatisch aan te vullen – ik kan gewoon rec userstypen en het zal kubectl delete -f ... ; kubectl create -f .... Als ik wil dat de hele installatie wordt gestart, typ ik recfo, en het maakt een tiental services opnieuw, haalt de nieuwste docker-afbeeldingen op, importeert de nieuwste db-dump van Staging env en ruimt oude Docker-bestanden op om ruimte te besparen .

Antwoord 5, autoriteit 6%

Ik ben net begonnen met Skaffold

Het is erg handig om wijzigingen in de code automatisch toe te passen op een lokaal cluster.

De beste manier om een ​​lokaal cluster te implementeren is Minikube of gewoon Docker voor Mac en Windows, beide hebben een Kubernetes-interface.

Antwoord 6, autoriteit 4%

Het hebben van een leuke feedbacklus voor lokale ontwikkeling is een onderwerp van snelle ontwikkeling in het Kubernetes-ecosysteem.

Om deze vraag op te lossen, er zijn een paar tools die dit doel naar mijn mening goed ondersteunen.

Docker voor Mac Kubernetes

Docker voor Mac Kubernetes(Docker Desktopis de generieke naam voor meerdere platforms) biedt een uitstekende optie voor lokale ontwikkeling. Voor virtualisatie gebruikt het HyperKitdat is gebouwd op het native Hypervisor-framework in macOS in plaats van VirtualBox.

De Kubernetes-functie werd voor het eerst uitgebracht als bètaversie op het edge-kanaal in januari 2018en heeft een lange weg afgelegd sinds hij een gecertificeerde Kubernetes werd in april 2018 en afstuderen naar het stabiele kanaal in Juli 2018.

Mijn ervaring is dat het veel gemakkelijker is om mee te werken dan Minikube, vooral op macOS, en vooral als het gaat om zaken als RBAC, Helm, hypervisor, privéregister, enz.

Roem

Wat betreft het verspreiden van uw code en het lokaal ophalen van updates, is Helmeen van de meest populaire opties. U kunt uw applicaties via CI/CD publiceren als Helm-diagrammen (en ook de onderliggende Docker-images waarnaar ze verwijzen). Vervolgens kunt u deze kaarten lokaal uit uw Helm-kaartregister halen en upgraden op uw lokale cluster.

Azure Draft

U kunt ook een tool zoals Azure Draftgebruiken om eenvoudige lokale implementaties uit te voeren en basis Helm-diagrammen te genereren op basis van gemeenschappelijke taalsjablonen , een soort buildpacks, om dat stukje van de puzzel te automatiseren.

Skaffold

Skaffoldlijkt op Azure Draft, maar is volwassener, veel breder van opzet en gemaakt door Google. Het heeft een zeer pluggable architectuur. Ik denk dat in de toekomst meer mensen het zullen gebruiken voor lokale app-ontwikkeling voor Kubernetes.

Als je React hebt gebruikt, zie ik Skaffold als “React-app makenvoor Kubernetes”.

Kompose of Compose op Kubernetes

Docker Composeis, hoewel niet gerelateerd aan Kubernetes, een alternatief dat sommige bedrijven gebruiken om een eenvoudige, gemakkelijke en draagbare lokale ontwikkelomgeving analoog aan de Kubernetes-omgeving die ze in productie draaien. Deze route volgen betekent echter dat je productie- en lokale ontwikkelingsopstellingen moeten afwijken.

Komposeis een Docker Compose naar Kubernetes-converter. Dit kan een handig pad zijn voor iemand die zijn toepassingen al lokaal als verzamelingen containers uitvoert.

Compose op Kubernetesis een recent open source(december 2018) aanbod van Docker waarmee Docker Compose kan worden geïmplementeerd bestanden rechtstreeks naar een Kubernetes-cluster via een aangepaste controller.

Antwoord 7, autoriteit 3%

Zie https://github.com/kubernetes/kubernetes/issues/12278voor het aankoppelen van een volume vanaf de hostmachine, het equivalent van:

docker run -v hostPath:ContainerPath

Antwoord 8, autoriteit 3%

Het nadeel van het gebruik van minkubeis dat het een andere virtuele machine over uw machine spawnt. Met de nieuwste minikube-versie moet je ook minimaal 2 CPU’s en 2 GB RAM van je systeem hebben, wat het behoorlijk zwaar maakt als je het systeem niet met voldoende middelen hebt.

Dit is de reden waarom ik ben overgestapt op microk8svoor ontwikkeling op kubernetes en ik vind het geweldig. microk8sondersteunt de DNS, lokale opslag, dashboard, istio, ingress en nog veel meer, alles wat je nodig hebt om je microservices te testen.

Het is ontworpen als een snelle en lichtgewicht upstream Kubernetes-installatie, geïsoleerd van uw lokale omgeving. Deze isolatie wordt bereikt door alle binaire bestanden voor Kubernetes, Docker.io, iptables en CNI in één enkelvoudig pakket te verpakken.

Een enkele node kubernetes-cluster kan binnen een minuut worden geïnstalleerd met een enkele opdracht:

snap install microk8s --classic

Zorg ervoor dat er geen docker- of kubelet-service op uw systeem draait. microk8szal alle vereiste services automatisch installeren.

Bekijk de volgende link om andere add-ons in microk8sin te schakelen.

https://github.com/ubuntu/microk8s

U kunt de status controleren met:

velotio@velotio-ThinkPad-E470:~/PycharmProjects/k8sClient$ microk8s.status
microk8s is running
addons:
ingress: disabled
dns: disabled
metrics-server: disabled
istio: disabled
gpu: disabled
storage: disabled
dashboard: disabled
registry: disabled

Antwoord 9

Kubesparyis handig bij het opzetten van lokale clusters. Meestal gebruikte ik een op zwerven gebaseerde cluster op een lokale machine.

Kubespray-configuratie
U kunt deze variabelen aanpassen om de gewenste kubernetes-versie te krijgen.

Antwoord 10

Zoals eerder aangegeven door Robert, is minikube de juiste keuze.

Hieris een korte handleiding om aan de slag te gaan met minikube. De algemene stappen zijn:

• Minikube installeren

• Maak minikube-cluster (in een virtuele machine die VirtualBox of Docker voor Mac of HyperV in het geval van Windows kan zijn)

• Maak een Docker-image van uw toepassingsbestand (met behulp van Dockerfile)

• Voer de afbeelding uit door een implementatie te maken

• Maak een service die uw toepassing openbaar maakt, zodat u er toegang toe hebt.

Antwoord 11

Bekijk https://github.com/okteto/oktetoen Okteto Cloud.
De waardepropositie is om de klassieke ontwikkelingservaring te hebben dan lokaal te werken, voorafgaand aan docker, waar u hot-reloads, incrementele builds, debuggers… kunt hebben, maar al uw lokale wijzigingen worden onmiddellijk gesynchroniseerd met een externe container. Externe containers geven u toegang tot de snelheid van de cloud, maken een nieuw niveau van samenwerking mogelijk en integreren ontwikkeling in een productie-achtige omgeving. Het elimineert ook de last van lokale installaties.

Antwoord 12

Dit is de manier waarop ik een lokale installatie voor Kubernetes in Windows 10 heb gedaan: –

• Gebruik Docker Desktop

• Schakel Kubernetes in in de instellingenoptie van Docker Desktop

• In Docker Desktop is de standaard toegewezen resource voor geheugen 2 GB, dus om Kubernetes te gebruiken
  met Docker Desktop vergroot u het geheugen.

• Installeer kubectl als client om met Kubernetes-cluster te praten

• Voer opdracht kubectl config get-contextsuit om het beschikbare cluster te krijgen

• Voer opdracht kubectl config use-context docker-desktopuit om de docker-desktop te gebruiken

• Maak een docker-image van uw applicatie

• Schrijf een YAML-bestand (beschrijvende methode om uw implementatie in Kubernetes te maken)
  naar de afbeelding die in het bovenstaande stappencluster is gemaakt

• Maak een service van het type node-poort beschikbaar voor elk van uw implementaties om deze beschikbaar te maken voor
  de buitenwereld