Kubernetes sembra incentrato sulla distribuzione di container in una nuvola di cluster. Quello che sembra non toccare è lo sviluppo e gli ambienti di messa in scena (o simili).

Durante lo sviluppo si vuole essere il più vicino possibile all'ambiente di produzione con alcune importanti modifiche:

• Distribuito localmente (o almeno da qualche parte a cui tu e solo tu puoi accedere )
• Usa il codice sorgente più recente sull'aggiornamento della pagina (supponendo che sia un sito web; idealmente la pagina si aggiorna automaticamente sul salvataggio del file locale che può essere fatto se monti il ​​codice sorgente e usi qualcosa come Yeoman ).

Allo stesso modo si può desiderare che un ambiente non pubblico faccia l' integrazione continua .

Kubernetes supporta questo tipo di ambiente di sviluppo o è qualcosa che si deve costruire, sperando che durante la produzione funzioni ancora?

Aggiornamento (15/07/2016)

Con il rilascio di Kubernetes 1.3, Minikube è ora il modo consigliato per eseguire Kubernetes sul tuo computer locale per lo sviluppo.

Puoi eseguire Kubernetes localmente tramite Docker . Una volta che hai un nodo in esecuzione, puoi avviare un pod che ha un semplice server web e monta un volume dalla tua macchina host. Quando colpisci il server web, leggerà dal volume e se hai cambiato il file sul tuo disco locale può servire la versione più recente.

Abbiamo lavorato a uno strumento per farlo. L'idea di base è che hai un cluster Kubernetes remoto, effettivamente un ambiente di staging, quindi esegui il codice in locale e viene inviato tramite proxy al cluster remoto. Ottieni un accesso alla rete trasparente, le variabili d'ambiente copiate, l'accesso ai volumi ... il più vicino possibile all'ambiente remoto, ma con il tuo codice in esecuzione localmente e sotto il tuo pieno controllo.

Quindi puoi fare lo sviluppo dal vivo, diciamo. Documenti su http://telepresence.io

Il tipo di "ricarica rapida" è qualcosa che abbiamo in programma di aggiungere, ma non è così facile come potrebbe essere oggi. Tuttavia, se ti senti avventuroso puoi usare rsync con docker exec, kubectl exec o osc exec (tutti fanno la stessa cosa più o meno) per sincronizzare una directory locale in un contenitore ogni volta che cambia. Puoi usare rsync con kubectl o osc exec in questo modo:

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

Un altro ottimo punto di partenza è questa configurazione Vagrant , specialmente. se il tuo sistema operativo host è Windows. Gli ovvi vantaggi sono

• configurazione rapida e indolore
• facile distruggere / ricreare la macchina
• limite implicito sulle risorse
• capacità di testare il ridimensionamento orizzontale creando più nodi

Gli svantaggi: hai bisogno di molta RAM e VirtualBox è VirtualBox ... nel bene o nel male.

Un vantaggio / svantaggio misto è la mappatura dei file tramite NFS. Nella nostra configurazione, abbiamo creato due serie di definizioni RC: una che scarica semplicemente un'immagine docker dei nostri server delle applicazioni; l'altra con 7 linee extra che impostano la mappatura dei file da HostOS -> Vagrant -> VirtualBox -> CoreOS -> Kubernetes pod; sovrascrivendo il codice sorgente dall'immagine Docker.

Lo svantaggio di questo è la cache dei file NFS: con essa è problematico, senza di essa è problematicamente lento. Anche l'impostazione mount_options: 'nolock,vers=3,udp,noac'non elimina completamente i problemi di memorizzazione nella cache, ma funziona la maggior parte delle volte. Alcune attività Gulp eseguite in un contenitore possono richiedere 5 minuti quando impiegano 8 secondi sul sistema operativo host. Un buon compromesso sembra essere mount_options: 'nolock,vers=3,udp,ac,hard,noatime,nodiratime,acregmin=2,acdirmin=5,acregmax=15,acdirmax=15'.

Per quanto riguarda il ricaricamento automatico del codice, è specifico del linguaggio, ma siamo soddisfatti del devserver di Django per Python e Nodemon per Node.js. Per i progetti di frontend, puoi ovviamente fare molto con qualcosa come gulp + browserSync + watch, ma per molti sviluppatori non è difficile servire da Apache e fare solo un hard refresh tradizionale.

Conserviamo 4 set di file yaml per Kubernetes. Dev, "devstable", stage, prod. Le differenze tra questi sono

• variabili env che impostano esplicitamente l'ambiente (dev / stage / prod)
• numero di repliche
• devstable, stage, prod utilizza immagini docker
• dev utilizza immagini Docker e mappa la cartella NFS con il codice sorgente su di esse.

È molto utile creare molti alias bash e il completamento automatico: posso semplicemente digitare rec userse lo farà kubectl delete -f ... ; kubectl create -f .... Se voglio che l'intera configurazione recfovenga avviata, digito e ricrea una dozzina di servizi, estraendo le ultime immagini Docker, importando l'ultimo dump db da Staging env e ripulendo i vecchi file Docker per risparmiare spazio.

Ho appena iniziato con Skaffold

È davvero utile applicare automaticamente le modifiche nel codice a un cluster locale.

Per distribuire un cluster locale, il modo migliore è Minikube o semplicemente Docker per Mac e Windows, entrambi includono un'interfaccia Kubernetes.

Vedi https://github.com/kubernetes/kubernetes/issues/12278 per come montare un volume dalla macchina host, l'equivalente di:

docker run -v hostPath:ContainerPath

Avere un bel ciclo di feedback sullo sviluppo locale è un argomento di rapido sviluppo nell'ecosistema Kubernetes.

Rompendo questa domanda, ci sono alcuni strumenti che credo supportino bene questo obiettivo.

Docker per Mac Kubernetes

Docker per Mac Kubernetes ( Docker Desktop è il nome generico multipiattaforma) offre un'opzione eccellente per lo sviluppo locale. Per la virtualizzazione, utilizza HyperKit che è costruito sul framework Hypervisor nativo in macOS invece di VirtualBox.

La funzione Kubernetes è stata rilasciata per la prima volta come beta sul canale edge nel gennaio 2018 e da allora ha fatto molta strada, diventando un Kubernetes certificato nell'aprile 2018 e passando al canale stabile nel luglio 2018 .

Nella mia esperienza, è molto più facile lavorare con Minikube, in particolare su macOS, e soprattutto quando si tratta di problemi come RBAC, Helm, hypervisor, registro privato, ecc.

Timone

Per quanto riguarda la distribuzione del codice e il recupero degli aggiornamenti a livello locale, Helm è una delle opzioni più popolari. Puoi pubblicare le tue applicazioni tramite CI / CD come grafici Helm (e anche le immagini Docker sottostanti a cui fanno riferimento). Quindi puoi estrarre questi grafici dal registro dei grafici Helm localmente e aggiornarli sul tuo cluster locale.

Azure Draft

Puoi anche usare uno strumento come Azure Draft per eseguire semplici distribuzioni locali e generare grafici Helm di base da modelli di linguaggio comune, un po 'come i buildpack, per automatizzare quel pezzo del puzzle.

Skaffold

Skaffold è come Azure Draft ma più maturo, molto più ampio e realizzato da Google. Ha un'architettura molto collegabile. Penso che in futuro più persone lo useranno per lo sviluppo di app locali per Kubernetes.

Se hai utilizzato React, penso a Skaffold come " Crea app React per Kubernetes".

Kompose o Compose su Kubernetes

Docker Compose , sebbene non correlato a Kubernetes, è un'alternativa che alcune aziende utilizzano per fornire un ambiente di sviluppo locale semplice, facile e portabile analogo all'ambiente Kubernetes che eseguono in produzione. Tuttavia, seguire questa strada significa divergere le impostazioni di produzione e di sviluppo locale.

Kompose è un convertitore da Docker Compose a Kubernetes. Questo potrebbe essere un percorso utile per qualcuno che esegue già le proprie applicazioni come raccolte di contenitori in locale.

Compose su Kubernetes è un'offerta open source di recente (dicembre 2018) di Docker che consente di distribuire file Docker Compose direttamente in un cluster Kubernetes tramite un controller personalizzato.

Kubespary è utile per creare cluster locali. Per lo più, ho usato un cluster basato su vagabondi sulla macchina locale.

Configurazione di Kubespray È possibile modificare queste variabili per ottenere la versione di Kubernetes desiderata.

Lo svantaggio dell'utilizzo di minkube è che genera un'altra macchina virtuale sulla tua macchina. Inoltre, con le ultimeminikube versione richiede almeno 2 CPU e 2 GB di RAM dal tuo sistema, il che lo rende piuttosto pesante se non hai il sistema con risorse sufficienti.

Questo è il motivo per cui sono passato allo microk8ssviluppo su Kubernetes e lo adoro.microk8ssupporta DNS, archiviazione locale, dashboard, istio, ingress e molti altri, tutto ciò di cui hai bisogno per testare i tuoi microservizi.

È progettato per essere un'installazione Kubernetes a monte veloce e leggera isolata dall'ambiente locale. Questo isolamento si ottiene impacchettando tutti i file binari per Kubernetes, Docker.io, iptables e CNI in un unico pacchetto snap.

Un cluster kubernetes a nodo singolo può essere installato in un minuto con un singolo comando:

snap install microk8s --classic

Assicurati che il tuo sistema non abbia alcun servizio docker o kubelet in esecuzione. Microk8sinstallerà automaticamente tutti i servizi richiesti.

Dai un'occhiata al seguente link per abilitare altri componenti aggiuntivi microk8s.

https://github.com/ubuntu/microk8s

Puoi controllare lo stato usando:

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

Dai un'occhiata a https://github.com/okteto/okteto e Okteto Cloud . La proposta di valore è quella di avere la classica esperienza di sviluppo rispetto al lavoro locale, prima del docker, dove è possibile avere ricariche a caldo, build incrementali, debugger ... ma tutte le modifiche locali vengono immediatamente sincronizzate su un container remoto. I container remoti ti danno accesso alla velocità del cloud, consentono un nuovo livello di collaborazione e integrano lo sviluppo in un ambiente simile alla produzione. Inoltre, elimina il peso delle installazioni locali.

Come specificato prima da Robert, minikube è la strada da percorrere.

Ecco una guida rapida per iniziare con minikube. I passaggi generali sono:

• Installa minikube

• Crea cluster minikube (in una macchina virtuale che può essere VirtualBox o Docker per Mac o HyperV in caso di Windows)

• Crea un'immagine Docker del file dell'applicazione (utilizzando Dockerfile)

• Esegui l'immagine creando una distribuzione

• Crea un servizio che esponga la tua applicazione in modo che tu possa accedervi.

Ecco come ho eseguito una configurazione locale per Kubernetes in Windows 10: -

• Usa Docker Desktop

• Abilita Kubernetes nell'opzione delle impostazioni di Docker Desktop

• In Docker Desktop per impostazione predefinita, la risorsa allocata per la memoria è di 2 GB, quindi utilizzare Kubernetes con Docker Desktop aumenta la memoria.

• Installa kubectl come client per parlare con il cluster Kubernetes

• Esegui il comando kubectl config get-contexts per ottenere il cluster disponibile

• Esegui il comando kubectl config use-context docker-desktop per utilizzare il desktop docker

• Crea un'immagine docker della tua applicazione

• Scrivi un file YAML (metodo descrittivo per creare la tua distribuzione in Kubernetes) che punta all'immagine creata nel cluster del passaggio precedente

• Esporre un servizio di tipo porta nodo per ciascuna distribuzione per renderlo disponibile al mondo esterno