Управители е новото дете в блока, обещаващо да помогне за внедряването на приложения в облака и да ги мащабира по-бързо. Днес, когато се разработва архитектура за микроуслуги, е доста стандартно да се избере Scala за създаване на API сървъри.
Микроуслугите заменят класическите монолитни сървъри с множество независими услуги, които комуникират помежду си и имат свои собствени процеси и ресурси.Ако има Стълба приложение в плановете си и вие искате мащаб в облак, значи сте на правилното място. В тази статия ще покажа стъпка по стъпка как да взема общо приложение Scala и да внедря Kubernetes с Docker, за да стартирам множество екземпляри на приложението. Крайният резултат ще бъде едно приложение, внедрено като множество екземпляри, и балансирано натоварване от Kubernetes.
Всичко това ще бъде изпълнено чрез просто импортиране на Изходен комплект Kubernetes във вашето приложение Scala. Моля, обърнете внимание, комплектът крие много сложни детайли, свързани с инсталирането и конфигурирането, но е достатъчно малък, за да бъде четлив и лесен за разбиране, ако искате да анализирате какво прави. За простота ще разположим всичко на вашата локална машина. Същата конфигурация обаче е подходяща за реално внедряване на Kubernetes в облак.
Бъдете умни и спете здраво, мащабирайте вашия Docker с Kubernetes. Tweet
Какво представлява Kubernetes?
Преди да влезем в кървавите подробности за изпълнението, нека обсъдим какво е Kubernetes и защо е важно.
Може би вече сте чували за Docker. В известен смисъл това е лека виртуална машина.
Docker дава предимството да разположи всеки сървър в изолирана среда, много подобна на самостоятелна виртуална машина, без сложността на управлението на пълноценна виртуална машина.
Поради тези причини той вече е един от най-широко използваните инструменти за разполагане на приложения в облаци. Изображението на Docker е доста лесно и бързо за изграждане и дублиране, много по-лесно от традиционната виртуална машина като VMWare, VirtualBox или XEN.
Kubernetes допълва Docker, предлагайки пълна среда за управление на докеризирани приложения. Използвайки Kubernetes, можете лесно да внедрявате, конфигурирате, оркестрирате, управлявате и наблюдавате стотици или дори хиляди приложения на Docker.
Kubernetes е инструмент с отворен код, разработен от Google и е приет от много други доставчици. Kubernetes е достъпен в облачната платформа на Google, но други доставчици са го приели и за своите облачни услуги OpenShift. Той може да бъде намерен на Amazon AWS, Microsoft Azure, RedHat OpenShift и дори повече облачни технологии. Можем да кажем, че е в добра позиция да се превърне в стандарт за внедряване на облачни приложения.
Предпоставки
След като разгледахме основните неща, нека проверим дали имате инсталиран целия необходим софтуер. На първо място, имате нужда Докер . Ако използвате Windows или Mac, имате нужда от Docker Toolbox . Ако използвате Linux, трябва да инсталирате конкретния пакет, предоставен от вашата дистрибуция или просто следвайте официалните указания .
изберете опцията, която представлява носима технология.
Ще кодираме в Scala, който е JVM език. Нужни са ви, разбира се, Java Development Kit и инструмент Scala SBT инсталиран и достъпен в глобалния път. Ако вече сте програмист на Scala, има вероятност тези инструменти да са вече инсталирани.
Ако използвате Windows или Mac, Docker по подразбиране ще създаде виртуална машина с име default само с 1 GB памет, което може да е твърде малко за стартиране на Kubernetes. Според моя опит имах проблеми с настройките по подразбиране. Препоръчвам ви да отворите графичния интерфейс на VirtualBox, да изберете вашата виртуална машина default и да промените паметта на поне до 2048MB.
Заявлението за клъстеризиране
Инструкциите в този урок могат да се отнасят за всяко приложение или проект на Scala. За да има в тази статия малко „месо“, върху което да работя, избрах пример, използван много често, за да демонстрирам прост микросервиз REST в Scala, наречен Akka HTTP . Препоръчвам ви да опитате да приложите изходния комплект към предложения пример, преди да се опитате да го използвате във вашето приложение. Тествах комплекта срещу демонстрационното приложение, но не мога да гарантирам, че няма да има конфликти с вашия код.
И така, първо започваме с клонирането на демонстрационното приложение:
git clone https://github.com/theiterators/akka-http-microservice След това проверете дали всичко работи правилно:
cd akka-http-microservice sbt run След това отворете http://localhost:9000/ip/8.8.8.8 и ще видите нещо като на следното изображение:
Добавяне на изходния комплект
Сега можем да добавим изходния комплект с малко Git магия:
git remote add ScalaGoodies https://github.com/sciabarra/ScalaGoodies git fetch --all git merge ScalaGoodies/kubernetes С това имате демонстрацията, включително изходния комплект, и сте готови да опитате. Или дори можете да копирате и поставите кода от там във вашето приложение.
След като обедините или копирате файловете във вашите проекти, сте готови да започнете.
Стартиране на Kubernetes
След като изтеглите комплекта, трябва да изтеглим необходимите kubectl двоичен, чрез изпълнение:
bin/install.sh Този инсталатор е достатъчно умен (надявам се), за да изтегли правилния kubectl двоичен за OSX, Linux или Windows, в зависимост от вашата система. Имайте предвид, че инсталаторът е работил върху системите, които притежавам. Моля, докладвайте за всякакви проблеми, за да мога да поправя комплекта.
След като инсталирате kubectl двоично, можете да стартирате целия Kubernetes в локалния си Docker. Просто бягай:
bin/start-local-kube.sh При първото стартиране тази команда ще изтегли изображенията на целия стек Kubernetes и локален регистър, необходим за съхраняване на вашите изображения. Това може да отнеме известно време, така че, моля, бъдете търпеливи. Също така имайте предвид, че се нуждае от директен достъп до интернет. Ако сте зад прокси, това ще бъде проблем, тъй като комплектът не поддържа прокси. За да го разрешите, трябва да конфигурирате инструментите като Docker, curl и т.н., за да използвате проксито. Доста сложно е, че препоръчвам да получите временен неограничен достъп.
как да си направя телеграма бот
Ако приемем, че сте успели да изтеглите всичко успешно, за да проверите дали Kubernetes работи добре, можете да въведете следната команда:
bin/kubectl get nodes Очакваният отговор е:
NAME STATUS AGE 127.0.0.1 Ready 2m Имайте предвид, че възрастта може да варира, разбира се. Освен това, тъй като стартирането на Kubernetes може да отнеме известно време, може да се наложи да извикате командата няколко пъти, преди да видите отговора. Ако не получите грешки тук, поздравления, имате Kubernetes и работи на вашата локална машина.
Докеризиране на приложението Scala
След като вече сте пуснали Kubernetes, можете да внедрите приложението си в него. В старите дни, преди Docker, трябваше да разположите цял сървър за стартиране на вашето приложение. С Kubernetes всичко, което трябва да направите, за да внедрите приложението си, е:
- Създайте изображение на Docker.
- Избутайте го в регистър, откъдето може да бъде стартиран.
- Стартирайте екземпляра с Kubernetes, който ще вземе изображението от системния регистър.
За щастие изглежда по-малко сложно, особено ако използвате инструмента за изграждане на SBT, както правят много.
В комплекта включих два файла, съдържащи всички необходими дефиниции за създаване на изображение, което може да стартира приложения на Scala или поне това, което е необходимо за стартиране на демонстрацията на Akka HTTP. Не мога да гарантирам, че ще работи с други приложения на Scala, но това е добра отправна точка и трябва да работи за много различни конфигурации. Файловете, които да търсите за изграждане на изображението на Docker са:
колко струва индустрията за красота през 2017 г
docker.sbt project/docker.sbt Нека да разгледаме какво има в тях. Файлът project/docker.sbt съдържа командата за импортиране на sbt-docker приставка:
addSbtPlugin('se.marcuslonnberg' % 'sbt-docker' % '1.4.0') Този плъгин управлява изграждането на изображението на Docker със SBT за вас. Определението на Docker е в docker.sbt файл и изглежда така:
imageNames in docker := Seq(ImageName('localhost:5000/akkahttp:latest')) dockerfile in docker := { val jarFile: File = sbt.Keys.`package`.in(Compile, packageBin).value val classpath = (managedClasspath in Compile).value val mainclass = mainClass.in(Compile, packageBin).value.getOrElse(sys.error('Expected exactly one main class')) val jarTarget = s'/app/${jarFile.getName}' val classpathString = classpath.files.map('/app/' + _.getName) .mkString(':') + ':' + jarTarget new Dockerfile { from('anapsix/alpine-java:8') add(classpath.files, '/app/') add(jarFile, jarTarget) entryPoint('java', '-cp', classpathString, mainclass) } } За да разберете напълно значението на този файл, трябва да познавате Docker достатъчно добре, за да разберете този файл с дефиниции. Въпреки това, ние не навлизаме в детайлите на файла за дефиниция на Docker, защото не е необходимо да го разбирате задълбочено, за да изградите изображението.
Красотата на използването на SBT за изграждане на имиджа на Docker е в товаSBT ще се погрижи за събирането на всички файлове вместо вас.
Обърнете внимание, че пътят на класа се генерира автоматично от следната команда:
val classpath = (managedClasspath in Compile).value Като цяло е доста сложно да се съберат всички JAR файлове, за да стартирате приложение. Използвайки SBT, файлът на Docker ще бъде генериран с add(classpath.files, '/app/'). По този начин SBT събира всички JAR файлове за вас и създава Dockerfile, за да стартира вашето приложение.
Останалите команди събират липсващите парчета, за да създадат образ на Docker. Изображението ще бъде изградено с помощта на съществуващ APT на изображението за стартиране на Java програми (anapsix/alpine-java:8, достъпно в интернет в Docker Hub). Други инструкции са добавяне на други файлове за стартиране на вашето приложение. И накрая, като посочим входна точка, можем да я стартираме. Обърнете внимание също, че името започва с localhost:5000 нарочно, защото localhost:5000 е мястото, където инсталирах системния регистър в start-kube-local.sh скрипт.
Изграждане на изображението на Docker със SBT
За да изградите изображението на Docker, можете да игнорирате всички подробности за Dockerfile. Трябва само да напишете:
sbt dockerBuildAndPush sbt-docker След това плъгинът ще изгради за вас образ на Docker, изтегляйки от интернет всички необходими парчета и след това ще насочи към регистъра на Docker, който е стартиран преди, заедно с приложението Kubernetes в localhost И така, всичко, от което се нуждаете, е да изчакате още малко, за да приготвите и подготвите изображението си.
Имайте предвид, че ако имате проблеми, най-доброто нещо, което трябва да направите, е да нулирате всичко до известно състояние, като изпълните следните команди:
bin/stop-kube-local.sh bin/start-kube-local.sh Тези команди трябва да спрат всички контейнери и да ги рестартират правилно, за да подготвят вашия регистър да получи изображението, изградено и изтласкано от sbt.
Стартиране на услугата в Kubernetes
Сега, когато приложението е опаковано в контейнер и избутано в регистър, ние сме готови да го използваме. Kubernetes използва командния ред и конфигурационните файлове за управление на клъстера. Тъй като командните редове могат да станат много дълги и да могат да репликират стъпките, аз използвам файловете с конфигурации тук. Всички мостри в изходния комплект са в папката kube.
Следващата ни стъпка е да стартираме един екземпляр на изображението. Работещо изображение се нарича, на езика Kubernetes, a под . Така че нека създадем шушулка, като извикаме следната команда:
финанси в музикалната индустрия
bin/kubectl create -f kube/akkahttp-pod.yml Вече можете да проверите ситуацията с командата:
bin/kubectl get pods Трябва да видиш:
NAME READY STATUS RESTARTS AGE akkahttp 1/1 Running 0 33s k8s-etcd-127.0.0.1 1/1 Running 0 7d k8s-master-127.0.0.1 4/4 Running 0 7d k8s-proxy-127.0.0.1 1/1 Running 0 7d Състоянието всъщност може да бъде различно, например „ContainerCreating“, може да отнеме няколко секунди, преди да стане „Running“. Също така можете да получите друго състояние като „Грешка“, ако например забравите да създадете изображението преди.
Можете също да проверите дали вашият шушулка работи с командата:
bin/kubectl logs akkahttp Трябва да видите изход, завършващ с нещо подобно:
[DEBUG] [05/30/2016 12:19:53.133] [default-akka.actor.default-dispatcher-5] [akka://default/system/IO-TCP/selectors/$a/0] Successfully bound to /0:0:0:0:0:0:0:0:9000 Сега услугата е настроена и работи в контейнера. Услугата обаче все още не е достъпна. Това поведение е част от дизайна на Kubernetes. Вашата шушулка работи, но трябва да я изложите изрично. В противен случай услугата е предназначена да бъде вътрешна.
Създаване на услуга
Създаването на услуга и проверката на резултата е въпрос на изпълнение:
bin/kubectl create -f kube/akkahttp-service.yaml bin/kubectl get svc Трябва да видите нещо подобно:
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE akkahttp-service 10.0.0.54 9000/TCP 44s kubernetes 10.0.0.1 443/TCP 3m Имайте предвид, че портът може да бъде различен. Kubernetes отдели порт за услугата и я стартира. Ако използвате Linux, можете директно да отворите браузъра и да напишете http://10.0.0.54:9000/ip/8.8.8.8 за да видите резултата. Ако използвате Windows или Mac с Docker Toolbox, IP адресът е локален за виртуалната машина, работеща с Docker, и за съжаление все още е недостъпен.
Тук искам да подчертая, че това не е проблем на Kubernetes, а по-скоро е ограничение на Docker Toolbox, което от своя страна зависи от ограниченията, наложени от виртуални машини като VirtualBox, които действат като компютър в друг компютър. За да преодолеем това ограничение, трябва да създадем тунел. За да улесня нещата, включих друг скрипт, който отваря тунел на произволен порт, за да достигне до всяка услуга, която сме разположили. Можете да въведете следната команда:
bin/forward-kube-local.sh akkahttp-service 9000 Имайте предвид, че тунелът няма да работи във фонов режим, трябва да държите прозореца на терминала отворен, стига да имате нужда от него, и да го затворите, когато вече не се нуждаете от тунела. Докато тунелът работи, можете да отворите: http://localhost:9000/ip/8.8.8.8 и накрая вижте приложението, работещо в Kubernetes.
Последно докосване: Мащаб
Досега сме „просто“ пуснали нашето приложение в Kubernetes. Макар да е вълнуващо постижение, то не добавя твърде голяма стойност към нашето внедряване. Спасени сме от усилията за качване и инсталиране на сървър и конфигуриране на прокси сървър за него.
Където блести Kubernetes е в мащабирането. Можете да разположите два, десет или сто екземпляра на нашето приложение, като промените само броя на репликите в конфигурационния файл. Така че нека го направим.
Ще спрем единичната шушулка и вместо това ще започнем внедряване. Така че нека изпълним следните команди:
как да получите номера на кредитни карти на хората онлайн
bin/kubectl delete -f kube/akkahttp-pod.yml bin/kubectl create -f kube/akkahttp-deploy.yaml След това проверете състоянието. Отново можете да опитате няколко пъти, защото разполагането може да отнеме известно време, за да се извърши:
NAME READY STATUS RESTARTS AGE akkahttp-deployment-4229989632-mjp6u 1/1 Running 0 16s akkahttp-deployment-4229989632-s822x 1/1 Running 0 16s k8s-etcd-127.0.0.1 1/1 Running 0 6d k8s-master-127.0.0.1 4/4 Running 0 6d k8s-proxy-127.0.0.1 1/1 Running 0 6d Сега имаме две шушулки, а не една. Това е така, защото в предоставения от мен конфигурационен файл има стойността replica: 2, с две различни имена, генерирани от системата. Не навлизам в подробности за конфигурационните файлове, тъй като обхватът на статията е просто въведение за програмистите на Scala, за да стартират в Kubernetes.
Както и да е, сега има две активни групи. Интересното е, че услугата е същата като преди. Конфигурирахме услугата да балансира натоварването между всички шушулки с етикет akkahttp. Това означава, че не трябва да преразпределяме услугата, но можем да заменим единичния екземпляр с репликиран.
Можем да проверим това, като стартираме проксито отново (ако сте в Windows и сте го затворили):
bin/forward-kube-local.sh akkahttp-service 9000 След това можем да се опитаме да отворим два терминални прозореца и да видим дневниците за всяка под. Например в първия тип:
bin/kubectl logs -f akkahttp-deployment-4229989632-mjp6u И във втория тип:
bin/kubectl logs -f akkahttp-deployment-4229989632-s822x Разбира се, редактирайте съответно командния ред със стойностите, които имате във вашата система.
Сега опитайте да получите достъп до услугата с два различни браузъра. Трябва да очаквате да видите заявките да бъдат разделени между множеството налични сървъри, както е на следното изображение:
Заключение
Днес едва надраскахме повърхността. Kubernetes предлага много повече възможности, включително автоматично мащабиране и рестартиране, постепенно внедряване и обеми. Освен това приложението, което използвахме като пример, е много просто, без гражданство, като различните случаи не се нуждаят да се познават. В реалния свят, разпределени приложения направете трябва да се познават и трябва да променят конфигурациите според наличността на други сървъри. Всъщност Kubernetes предлага разпределено хранилище на ключове (etcd), за да позволи на различни приложения да комуникират помежду си, когато се разполагат нови екземпляри. Този пример обаче е целенасочено достатъчно малък и опростен, за да ви помогне да започнете, като се фокусирате върху основните функции. Ако следвате урока, трябва да можете да получите работна среда за вашия Стълба приложение на вашата машина, без да се обърквате от голям брой детайли и да се губите в сложността.
