Wydaje się, że Kubernetes polega na wdrażaniu kontenerów w chmurze klastrów. To, czego wydaje się nie dotykać, to środowiska programistyczne i przejściowe (lub takie).

Podczas programowania chcesz być jak najbliżej środowiska produkcyjnego z kilkoma ważnymi zmianami:

• Wdrożone lokalnie (lub przynajmniej w miejscu, do którego Ty i tylko Ty macie dostęp )
• Użyj najnowszego kodu źródłowego podczas odświeżania strony (przypuśćmy, że jest to witryna internetowa; najlepiej jest automatycznie odświeżać stronę podczas zapisywania pliku lokalnego, co można zrobić, jeśli zamontujesz kod źródłowy i użyjesz czegoś takiego jak Yeoman ).

Podobnie można chcieć, aby środowisko niepubliczne dokonywało ciągłej integracji .

Czy Kubernetes obsługuje tego rodzaju środowisko programistyczne, czy jest to coś, co trzeba zbudować, mając nadzieję, że podczas produkcji nadal będzie działać?

Aktualizacja (2016-07-15)

Wraz z wydaniem Kubernetes 1.3, Minikube jest teraz zalecanym sposobem uruchamiania Kubernetes na komputerze lokalnym w celu programowania.

Możesz uruchomić Kubernetes lokalnie przez Docker . Gdy masz już uruchomiony węzeł, możesz uruchomić pod, który ma prosty serwer WWW i montuje wolumin z komputera hosta. Kiedy trafisz na serwer WWW, odczyta on z woluminu, a jeśli zmienisz plik na dysku lokalnym, może on obsługiwać najnowszą wersję.

Pracowaliśmy nad narzędziem, które to umożliwi. Podstawowa idea jest taka, że ​​masz zdalny klaster Kubernetes, efektywnie środowisko przejściowe, a następnie uruchamiasz kod lokalnie i jest on przekazywany do zdalnego klastra. Otrzymujesz przejrzysty dostęp do sieci, kopiowanie zmiennych środowiskowych, dostęp do woluminów ... tak blisko zdalnego środowiska, jak to tylko możliwe, ale kod działa lokalnie i pod Twoją pełną kontrolą.

Powiedzmy, że możesz rozwijać się na żywo. Dokumenty na http://telepresence.io

Planujemy dodać coś w rodzaju „gorącego przeładowania”, ale nie jest to tak łatwe, jak mogłoby być dzisiaj. Jeśli jednak masz ochotę na przygodę, możesz użyć rsync z docker exec, kubectl exec lub osc exec (wszystkie z grubsza robią to samo), aby zsynchronizować lokalny katalog z kontenerem za każdym razem, gdy się zmieni. Możesz użyć rsync z kubectl lub osc exec w następujący sposób:

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

Kolejnym świetnym punktem wyjścia jest konfiguracja Vagrant , zwł. jeśli twoim głównym systemem operacyjnym jest Windows. Oczywiste zalety to

• szybka i bezbolesna konfiguracja
• łatwe do zniszczenia / odtworzenia maszyny
• ukryty limit zasobów
• możliwość testowania skalowania poziomego poprzez tworzenie wielu węzłów

Wady - potrzebujesz dużo pamięci RAM, a VirtualBox to VirtualBox ... na dobre lub na złe.

Mieszaną zaletą / wadą jest mapowanie plików przez NFS. W naszej konfiguracji stworzyliśmy dwa zestawy definicji RC - jeden, który po prostu pobiera obraz dockera naszych serwerów aplikacji; druga z 7 dodatkowymi liniami, które konfigurują mapowanie plików z HostOS -> Vagrant -> VirtualBox -> CoreOS -> Kubernetes pod; nadpisanie kodu źródłowego z obrazu platformy Docker.

Wadą tego jest pamięć podręczna plików NFS - z nią jest problematyczna, bez niej jest problematycznie powolna. Nawet ustawienie mount_options: 'nolock,vers=3,udp,noac'nie eliminuje całkowicie problemów z buforowaniem, ale działa przez większość czasu. Niektóre zadania Gulp uruchomione w kontenerze mogą zająć 5 minut, jeśli zajmują 8 sekund w systemie operacyjnym hosta. Wydaje się, że jest to dobry kompromis mount_options: 'nolock,vers=3,udp,ac,hard,noatime,nodiratime,acregmin=2,acdirmin=5,acregmax=15,acdirmax=15'.

Jeśli chodzi o automatyczne przeładowywanie kodu, to jest to specyficzne dla języka, ale jesteśmy zadowoleni z devserver Django dla Pythona i Nodemon dla Node.js. W przypadku projektów frontendowych możesz oczywiście wiele zrobić za pomocą czegoś takiego jak gulp + browserSync + watch, ale dla wielu programistów nie jest trudno obsługiwać z Apache i po prostu robić tradycyjne twarde odświeżanie.

Przechowujemy 4 zestawy plików yaml dla Kubernetes. Dev, "devstable", scena, prod. Różnice między nimi są

• zmienne env jawnie ustawiające środowisko (dev / stage / prod)
• liczba replik
• devstable, stage, prod używa obrazów dockera
• dev używa obrazów dockera i mapuje folder NFS z kodem źródłowym na nich.

Bardzo przydatne jest tworzenie wielu aliasów bash i autouzupełniania - mogę po prostu wpisać rec usersi to zrobi kubectl delete -f ... ; kubectl create -f .... Jeśli chcę, aby cała konfiguracja została uruchomiona, piszę recfoi odtwarza kilkanaście usług, pobierając najnowsze obrazy dockera, importując najnowszy zrzut bazy danych z Staging env i czyszcząc stare pliki Dockera, aby zaoszczędzić miejsce.

Właśnie zacząłem ze Skaffoldem

Naprawdę przydatne jest automatyczne stosowanie zmian w kodzie w lokalnym klastrze.

Aby wdrożyć lokalny klaster, najlepszym sposobem jest Minikube lub tylko Docker dla komputerów Mac i Windows, oba zawierają interfejs Kubernetes.

Zobacz https://github.com/kubernetes/kubernetes/issues/12278, aby dowiedzieć się, jak zamontować wolumin z komputera hosta, odpowiednik:

docker run -v hostPath:ContainerPath

Posiadanie ładnej pętli sprzężenia zwrotnego lokalnego rozwoju jest tematem szybkiego rozwoju w ekosystemie Kubernetes.

Rozstrzygając to pytanie, jest kilka narzędzi, które moim zdaniem dobrze wspierają ten cel.

Docker for Mac Kubernetes

Docker for Mac Kubernetes ( Docker Desktop to ogólna nazwa międzyplatformowa) stanowi doskonałą opcję do lokalnego programowania. Do wirtualizacji używa HyperKit, który jest zbudowany na natywnej strukturze Hypervisora ​​w macOS zamiast VirtualBox.

Funkcja Kubernetes została po raz pierwszy wydana w wersji beta na kanale brzegowym w styczniu 2018 r. I od tego czasu przeszła długą drogę, stając się certyfikowanym Kubernetesem w kwietniu 2018 r. I przechodząc do wersji stabilnej w lipcu 2018 r .

Z mojego doświadczenia wynika, że ​​praca z Minikube jest o wiele łatwiejsza, szczególnie na macOS, a zwłaszcza w przypadku problemów takich jak RBAC, Helm, hiperwizor, prywatny rejestr itp.

Hełm

Jeśli chodzi o dystrybucję kodu i lokalne pobieranie aktualizacji, Helm jest jedną z najpopularniejszych opcji. Możesz publikować swoje aplikacje za pośrednictwem ciągłej integracji / ciągłego wdrażania jako wykresy Helm (a także podstawowe obrazy platformy Docker, do których się odnoszą). Następnie możesz pobrać te wykresy lokalnie z rejestru wykresów Helm i przeprowadzić uaktualnienie w lokalnym klastrze.

Wersja robocza Azure

Możesz również użyć narzędzia takiego jak Azure Draft, aby wykonać proste wdrożenia lokalne i wygenerować podstawowe wykresy Helm na podstawie szablonów wspólnego języka, podobnie jak pakiety kompilacji, w celu zautomatyzowania tego elementu układanki.

Skaffold

Skaffold jest podobny do Azure Draft, ale jest bardziej dojrzały, ma znacznie szerszy zakres i został stworzony przez Google. Ma bardzo łatwo podłączalną architekturę. Myślę, że w przyszłości więcej osób będzie go używać do lokalnego tworzenia aplikacji dla Kubernetes.

Jeśli używałeś Reacta, myślę o Skaffoldzie jako „ Utwórz aplikację React dla Kubernetes”.

Komponuj lub twórz na Kubernetes

Docker Compose , choć niezwiązany z Kubernetes, jest jedną z alternatyw, z której korzystają niektóre firmy, aby zapewnić proste, łatwe i przenośne lokalne środowisko programistyczne, analogiczne do środowiska Kubernetes, które działają w środowisku produkcyjnym. Jednak pójście tą drogą oznacza odejście od konfiguracji produkcji i lokalnego rozwoju.

Kompose to konwerter Docker Compose na Kubernetes. Może to być przydatna ścieżka dla kogoś, kto już uruchamia swoje aplikacje jako kolekcje kontenerów lokalnie.

Compose on Kubernetes to niedawno otwarta (grudzień 2018 r.) Oferta firmy Docker, która umożliwia wdrażanie plików Docker Compose bezpośrednio w klastrze Kubernetes za pośrednictwem niestandardowego kontrolera.

Kubespary jest pomocny w konfigurowaniu lokalnych klastrów. Przeważnie używałem klastra opartego na włóczęgach na komputerze lokalnym.

Konfiguracja Kubespray Możesz dostosować te zmienne, aby uzyskać żądaną wersję kubernetes.

Wadą używania minkubejest to, że tworzy on inną maszynę wirtualną na twojej maszynie. Również z najnowszymiminikube wersji minimum wymaga posiadania 2 procesorów i 2 GB pamięci RAM w systemie, co czyni go dość ciężkim, jeśli nie masz systemu z wystarczającymi zasobami.

To jest powód, dla którego przerzuciłem się microk8sna programowanie na kubernetes i uwielbiam to. microk8sobsługuje DNS, magazyn lokalny, pulpit nawigacyjny, istio, dane wejściowe i wiele innych - wszystko, czego potrzebujesz do testowania mikrousług.

Został zaprojektowany jako szybka i lekka instalacja Kubernetes nadrzędna, odizolowana od lokalnego środowiska. Ta izolacja jest osiągana poprzez pakowanie wszystkich plików binarnych dla Kubernetes, Docker.io, iptables i CNI w jednym pakiecie snap.

Klaster kubernetes z pojedynczym węzłem można zainstalować w ciągu minuty za pomocą jednego polecenia:

snap install microk8s --classic

Upewnij się, że w systemie nie jest uruchomiona żadna usługa Docker ani Kubelet. Microk8sautomatycznie zainstaluje wszystkie wymagane usługi.

Proszę spojrzeć na poniższy link, aby włączyć inne dodatki microk8s.

https://github.com/ubuntu/microk8s

Możesz sprawdzić status za pomocą:

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

Zajrzyj na https://github.com/okteto/okteto i Okteto Cloud . Propozycja wartości polega na tym, aby mieć klasyczne doświadczenie programistyczne niż praca lokalna, przed dokerem, gdzie można mieć ponowne ładowanie na gorąco, kompilacje przyrostowe, debugery ... ale wszystkie lokalne zmiany są natychmiast synchronizowane ze zdalnym kontenerem. Zdalne kontenery zapewniają dostęp do szybkości chmury, umożliwiają nowy poziom współpracy i integrują programowanie w środowisku podobnym do produkcji. Eliminuje również obciążenie lokalnych instalacji.

Jak określił wcześniej Robert, najlepszym rozwiązaniem jest minikube.

Oto krótki przewodnik po minikube. Ogólne kroki to:

• Zainstaluj minikube

• Utwórz klaster minikube (na maszynie wirtualnej, którą może być VirtualBox lub Docker dla komputerów Mac lub HyperV w przypadku systemu Windows)

• Utwórz obraz Dockera pliku aplikacji (przy użyciu Dockerfile)

• Uruchom obraz, tworząc Deployment

• Utwórz usługę, która ujawni Twoją aplikację, abyś mógł uzyskać do niej dostęp.

Oto sposób, w jaki wykonałem lokalną konfigurację Kubernetes w systemie Windows 10: -

• Użyj Docker Desktop

• Włącz Kubernetes w opcji ustawień Docker Desktop

• Na pulpicie Docker domyślnie przydzielony zasób pamięci to 2 GB, więc aby użyć Kubernetes z Docker Desktop, zwiększ pamięć.

• Zainstaluj kubectl jako klienta, aby rozmawiać z klastrem Kubernetes

• Uruchom polecenie kubectl config get-contexts, aby uzyskać dostępny klaster

• Uruchom polecenie kubectl config use-context docker-desktop, aby użyć pulpitu docker

• Utwórz obraz dockera swojej aplikacji

• Napisz plik YAML (opisowa metoda tworzenia wdrożenia w Kubernetes) wskazujący na obraz utworzony w powyższym klastrze kroku

• Ujawnij usługę typu port węzła dla każdego wdrożenia, aby udostępnić ją światu zewnętrznemu