Găzduiește-ți aplicația pe Google Kubernetes Engine

Fotografie de True Agency pe Unsplash
Ca dezvoltator, este întotdeauna o sarcină descurajantă să-ți găzduiești creația pe o altă platformă decât o platformă ca un serviciu, de exemplu Heroku.

În acest articol vă voi conduce prin procesul de implementare a unei aplicații într-o infrastructură ca un serviciu, de exemplu Google Kubernetes Engine și sper că va remedia teama dvs. de servicii de găzduire la nivel inferior.

sursa: presslabs.com

Vom face următorii pași pentru a găzdui aplicația noastră:

  1. Crearea clusterului Kubernetes
  2. Dockerizarea aplicației
  3. Configurați configurația Kubernetes
  4. Instalare și configurare Nginx
  5. Configurare DNS
  6. Furnizarea de certificate SSL (Secure Socket Layer)

Aplicația

Aplicația are un frontend construit cu React și backend (API construită cu Python Flask și Postgresql ca bază de date).

React, flacon Python și Postgres
Aceasta este practic o implementare a arhitecturii pe trei niveluri; stratul de prezentare (frontend), stratul logic (API) și stratul de date (baza de date) sunt toate separate și independente.
Aplicația este o aplicație „bucketlist” în care un utilizator poate înregistra acolo articole bucketlist împreună cu elemente de acțiune cu privire la modul în care le va realiza.

Primul pas pentru găzduirea acestei aplicații pe GKE este de a-l depozita. Adică, dockerizing fiecare dintre cele 3 niveluri ale aplicației. Clonați acest depozit pentru a urma.

Cerințe preliminare

Instrumentele pe care le vom folosi în acest articol includ următoarele:

  1. kubectl
  2. gcloud
  3. docher
  4. proiect Google google

Urmați instrucțiunile de pe ecran pentru a vă configura cu instrumentele de mai sus. Aceasta poate implica logarea în contul dvs. de Google Cloud.

Dacă nu le aveți deja configurate, continuați și configurați aceste link-uri. Dacă le aveți deja configurate, să le potrivim.

Crearea clusterului Kubernetes

Începem creând un cluster kubernetes și, în același timp, configurăm toate acreditările necesare pentru a interacționa cu clusterul nou creat.

Există mai multe moduri de a crea un cluster în kubernetes; printre acestea se numără utilizarea google cloud console, linia de comandă (gcloud) sau REST.

Pentru aceasta vom folosi linia de comandă (gcloud). Acest lucru ne permite să lucrăm de la terminalul nostru cu care dezvoltator aveți proces cu care lucrați. Continuați și setați mai întâi aceste variabile de mediu.

Am reunit toate aceste variabile de mediu într-un fișier env.sh, pe terminalul dvs. puteți rula „source env.sh” pentru a le popula pe toate simultan.
  1. $ PROIECT: acesta este ID-ul proiectului Google. Același proiect pe care l-ați creat sau doriți să îl utilizați pentru acest proiect.
  2. $ CLUSTER: acesta este numele clusterului pe care doriți să îl creați.
  3. $ ZONE: aceasta este zona în care va fi creat clusterul.
  4. $ GCR_REGISTRY: acesta este registrul gcr la care aveți imaginile containerului.
  5. $ FRONTEND_DOCKER_IMAGE_NAME: acesta este numele imaginii pe care doriți să o aibă imaginea containerului frontend.
  6. $ DATABASE_DOCKER_IMAGE_NAME: acesta este numele imaginii pe care doriți să o aibă imaginea containerului dvs. de bază de date.
  7. $ BACKEND_API_DOCKER_IMAGE_NAME: acesta este numele imaginii pe care doriți să o aibă imaginea containerului api.

Înainte de a crea clusterul, încă nu avem încă o piesă a puzzle-ului. Un cont de servicii. îndreptați-vă aici și creați un cont de servicii și asigurați-vă că îi atribuiți aceste roluri:

  1. roles / storage.admin așa cum este menționat aici
  2. roluri / project.owner

După ce toate acele variabile de mediu sunt setate și conturile de servicii și rolurile sunt alocate, atunci puteți rula această comandă:

container gcloud beta - proiectul clusterele „$ PROJECT” creează „$ CLUSTER” - zona „$ ZONE”

Această comandă va dura câteva minute pentru a fi finalizată. După finalizare, va fi completat și fișierul de credințe, după cum este necesar pentru a interacționa cu clusterul kubernetes nou creat.

Acum că avem un cluster, să începem jocurile kubernetes.

Dockerizarea aplicației

sursa: cengn.ca

Am configurat aplicația într-un mod în care fiecare nivel are folderul său. Acest lucru face mai ușoară organizarea fișierului de fixare al fiecărui nivel.

Pe terminalul dvs., schimbați directorul în folderul frontend. Deoarece această aplicație este sub controlul versiunii, asigurați-vă că verificați sucursala pentru care doriți să construiți imaginea docker.

Doar pentru a fi organizat pe toate cele 3 niveluri, am introdus toate fișierele legate de docker în directorul / docker. Așadar, în timp ce se află în rădăcina folderului de aplicații frontend, executați această comandă

build docker -t $ GCR_REGISTRY / $ PROJECT / $ FRONTEND_DOCKER_IMAGE_NAME: v1 -f docker / Dockerfile.

Acest proces va dura câteva minute în timp ce construiește și configurează imaginea docker pentru nivelul frontend. Când se construiește, mergeți mai departe și construiți și API-ul și bazele de date ale bazei de date.

Încă în terminalul dvs., schimbați directorul în folderul api și executați această comandă pentru a construi imaginea docker API backend.

construirea docker -t $ GCR_REGISTRY / $ PROJECT / $ BACKEND_API_DOCKER_IMAGE_NAME: v1 -f docker / Dockerfile.

Și, în sfârșit, să construim pentru nivelul bazei de date. Pe terminalul dvs. schimbați directorul în folderul bazei de date și executați:

build docker -t $ GCR_REGISTRY / $ PROJECT / $ DATABASE_DOCKER_IMAGE_NAME: v1 -f docker / Dockerfile.

Cu comenzile de mai sus completate cu succes, vom avea 3 imagini de andocare; Frontend, API și bază de date local pe desktop / laptop. Continuați și editați fișierul deployments.yaml din folderul k8s-configuration cu numele imaginilor docker nou create.

Pentru ca Google Kubernetes Engine să folosească aceste imagini, trebuie să le facem accesibile. Un mod de a face acest lucru este prin împingerea acestora în Registrul de conținut Google.

Registrul Google Container, sursa: blog.deimos.fr
Aceasta este versiunea Google Cloud Platform a hub-ului docker; depozitul de imagini pentru containere Google.

În terminalul dvs., executați:

gcloud auth configure-docker

Acest lucru va configura docker-ul pentru a utiliza repertoriile oficiale de imagini ale docker-ului Google, cum ar fi gcr.io, eu.gcr.io, us.gcr.io, astfel încât să împingeți o imagine docker către acele depozite, o faceți la fel ca faci pentru docker.

Haideți să împingem acum toate cele 3 imagini către Google Container Registry, pur și simplu rulați:

docker push $ GCR_REGISTRY / $ PROJECT / $ FRONTEND_DOCKER_IMAGE_NAME: v1 && docker push $ GCR_REGISTRY / $ PROJECT / $ BACKEND_API_DOCKER_IMAGE_NAME: v1 && docker push $ GCR_REGISTRY / $ PROJECT / $ DATABIM_

Cu asta complet, să ne adresăm acum elefantului din cameră; Implementarea aplicației în Google Kubernetes Engine.

sursa: google.com

Structura folderului de configurare Kubernetes

Am plasat toate fișierele de configurare kubernetes în folderul k8s-configurații. Aici avem configurații de implementare, intrare, secrete și servicii, grupate în fișiere yaml numite în mod similar.

  1. deployments.yaml. O implementare este pur și simplu o „sarcină de lucru” care conține configurațiile pod-ului pentru aplicații (care conține un container). Acest fișier de configurare conține imaginea containerului, porturi, etichete, număr de replici etc.
  2. services.yaml. În kubernetes, serviciile sunt „lipiciul” diferitelor „sarcini de lucru”. Acestea asigură conectivitatea între containerele din ecosistemul kubernetes. Acest lucru se datorează faptului că, modul în care kubernetes a fost creat, un container, nu poate „vorbi” cu un alt container, dacă nu în același pod. În esență, frontend-ul și API-ul nu se vor „vorbi” între ei direct, dacă nu în aceeași platformă și pentru această configurare, nu se află în același pod. De aceea trebuie să folosim servicii.
  3. ingress.yaml. În kubernetes, intrarea este un set de reguli care direcționează traficul extern extern către servicii dintr-un cluster kubernetes. Acest lucru este util dacă aveți multe servicii care trebuie să expună implementările pe internet. Odată cu intrarea, utilizați doar un echilibrator de încărcare HTTP și va gestiona traficul pentru toate acele implementări care au nevoie de internet, spre deosebire de utilizarea unui echilibrator de sarcină separat pentru fiecare, care poate fi costisitor din punct de vedere al costurilor de cloud computing.
  4. secrets.yaml. Pentru aplicația noastră, secretul de care avem nevoie este un certificat SSL pentru a facilita rezilierea SSL. Acest lucru va permite accesarea aplicației noastre în siguranță prin HTTPS.

Să mergem acum înainte și să transformăm conținutul fișierelor de configurare kubernetes în resurse reale de calcul cloud.

Cea mai bună practică Google este să creăm servicii mai întâi înainte de implementare. Așa că vom aplica mai întâi fișierul de configurare services.yaml. Întoarceți-vă la folderul k8s-configuration și începeți să transformați codul în resurse de calcul reale.

Pe terminalul dvs., în folderul de configurare k8s, rulați:

kubectl create -f services.yaml

Produsul ar trebui să arate astfel:

ieșire iterm
Această comandă va crea fiecare resursă declarată în fișierul services.yaml dat.
Acesta este modul declarativ de creare a resurselor kubernetes; declarați-le pe toate într-un fișier yaml și treceți acel fișier folosind indicatorul -f la comanda kubectl create și toată magia se întâmplă după aceea.

Faceți același lucru pentru fișierul secrets.yaml, fișierul ingress.yaml și pentru fișierul deployments.yaml. Alerga:

kubectl crea -f ingress.yaml && kubectl crea -f deployments.yaml && kubectl crea -f secrets.yaml

Cu acea comandă finalizată cu succes, îndreptați-vă către consola GCP în secțiunea motorul> volumul de lucru kubernetes și veți găsi resursele pe care tocmai le-ați creat.

Tabloul de bord Google Kubernetes Engine

Dacă nu vedeți nimic, asigurați-vă că ați trecut la contul corect pe care l-ați configurat pentru acest proiect, în colțul din dreapta sus și asigurați-vă că ați selectat proiectul corect în colțul din stânga sus, așa cum se arată mai jos.

tabloul de bord al consolei platformei Google Cloud

Aruncați o privire la secțiunea sarcini de lucru, ar trebui să aveți frontend-ul, API-ul și baza de date funcționate cu indicatori de bifare verzi.

Tabloul de bord cu sarcini GKE

Căutați-vă și la secțiunea servicii și asigurați-vă că toate serviciile sunt sănătoase și cu indicatoare ecologice.

Tabloul de bord al serviciilor GKE

În acest moment, totul este bine să mergi, cu excepția unui lucru. Un controler de intrare, fără de care nu putem accesa nicio parte a aplicației noastre pe Google Cloud prin browser.

Un controler Ingress este responsabil pentru îndeplinirea Ingress, de obicei cu un bilanț de sarcină. Crearea unei resurse de intrare nu va funcționa fără un controler de intrare. Din fericire pentru noi, și pentru cârma, nu trebuie să intrăm în detaliile complexe ale instalării unui controler de intrare de la zero.

Configurarea controlerului

Pentru a pune în funcțiune un controler Ingress în clusterul nostru, vom folosi cârma.

sursa: google.com
Helm este pentru Kubernetes ce înseamnă homebrew la macOS, apt-get este ubuntu și pip este python. Este un manager de pachete pentru Kubernetes.

Helm ne permite să instalăm dependențe și aplicații întregi care au fost grupate într-un pachet cu o singură comandă. Începem prin instalarea și configurarea helmei.

În terminalul dvs., executați:

curl -o get_helm.sh https://raw.githubusercontent.com/kubernetes/helm/master/scripts/get && chmod + x get_helm.sh && ./get_helm.sh && helm init

Comanda de mai sus preia cea mai recentă versiune a clientului helm și o instalează pe mașina locală (laptop / desktop)

Pentru ca helm să funcționeze cu clusterul nostru, are nevoie de o componentă din partea serverului instalată în cluster cu care helmul va „vorbi” pentru a gestiona și trece comenzile pentru a crea toate resursele de care avem nevoie, pentru acest caz, de un Ingress controlor.

Această componentă se numește Tiller. Pentru a instala tillerul într-un cluster Google Kubernetes, trebuie să avem un cont de serviciu și un rol de legătură de cluster configurat pentru tiller. Acest lucru va permite tillerului să poată instala resurse kubernetes în clusterul nostru.

În terminalul dvs., executați următoarele comenzi pentru instalarea și configurarea tillerului, după cum este necesar:

kubectl create serviceaccount - namespace kube-system tiller && kubectl create clusterrolebinding tiller-cluster-rule --clusterrole = cluster-admin --serviceaccount = kube-system: tiller && kubectl patch deploy --namespace kube-system tiller-deploy -p '{"Spec": {"template": {"spec": {"serviceAccount": "tiller"}}}}} "

Pentru a confirma instalarea motocultorului, executați:

kubectl obține implementări -n kube-system | grep tiller-deploy

Aceasta va genera implementarea tiller-dploy nou creată.

Acum am instalat și configurat cârma și caroseria atât în ​​stația noastră de lucru locală, cât și în clusterul de la distanță. Acum putem merge înainte și instala un controler Ingress în clusterul nostru.

nginx intrare pentru GKE

Există o varietate de controlere Ingress, pentru aceasta, vom folosi controlorul Ingress nginx așa cum am declarat în fișierul nostru de configurare ingress.yaml. În rularea terminalului:

helm install - nume nginx-ingress stabil / nginx-ingress --set rbac.create = true

Aceasta va instala controlorul nginx Ingress. Pentru a confirma instalarea noastră, executați:

kubectl get service nginx-ingress-controller

Aceasta vă va oferi o ieșire a serviciului controlerului nginx de tip loadBalancer cu un IP extern.

Acest IP extern necesită puțin timp pentru a fi creat, așa că dacă vedeți „în așteptare”, acordați câteva secunde / minute pentru ca Google să-l furnizeze.

În acest moment, puteți accesa frontendul prin IP-ul extern al serviciului de control de acces nginx. Dar la fel ca sărea, de ce să fie obișnuit . Să conectăm IP-ul cu un nume de domeniu, astfel încât să-l putem accesa prin ceva ca http://www.myapp.com în loc de http://35.90.3.9.

Dacă nu aveți unul, puteți cumpăra unul din like-urile godaddy, hover, google-domains, etc. Haideți să configurăm acum domeniul nostru.

Configurare DNS

sursa: pngall.com

Am folosit propriul meu nume de domeniu pe care îl voi scoate la o săptămână după acest articol demonstrativ. Accesați panoul de bord al domeniului dvs. și configurați câteva nume de subdomeniu pentru frontend, api și baza de date.

Numele meu de domeniu este davidmukiibi.com și subdomeniile pe care le-am creat arată așa:

frontend.davidmukiibi.com
api.davidmukiibi.com
database.davidmukiibi.com
plasați pe tabloul de bord al domeniului

În terminalul dvs., executați:

kubectl primi servicii | grep LoadBalancer | awk '{print $ 4}'

Copiați ieșirea comenzii respective; aceasta este adresa IP externă prin care aplicația noastră este expusă la internet.

În tabloul de bord al domeniului dvs., completați această adresă IP externă ca valoare pentru cele 3 seturi de înregistrări pe care le-am creat.

Dacă verificați fișierul nostru ingress.yaml, veți observa că am solicitat controlerului nostru de intrare prin intermediul resursei de intrare să forțeze redirecționarea oricărei solicitări către https folosind această adnotare:

nginx.ingress.kubernetes.io/ssl-redirect: "adevărat"

Acest lucru va permite doar conexiuni sigure prin aplicația noastră.

Permiterea numai conexiuni sigure la aplicația dvs. este o bună practică, mai ales dacă funcționează cu datele utilizatorului. Acestea fiind spuse, avem nevoie de un certificat SSL pentru a permite criptarea end-to-end între aplicația noastră și utilizator.

sursa: google.com

Vom folosi criptarea, deoarece oferă certificate SSL gratuite valabile timp de 3 luni. Puteți utiliza orice certificate dacă aveți, indiferent dacă sunt plătite sau gratuite.

Asigurarea certificatului SSL

Pentru a achiziționa certificatele SSL de la criptarea, vom folosi un instrument numit certbot. Instalați lăsați cifrarea și certificatul.

Schimbați directorul în folderul de configurare k8s, dacă utilizați ubuntu linux, executați:

apt-get instalați lasă criptare

Dacă utilizați macOS, rulați:

brew instalați certificbot &&pp instalați lascriptă --user
Accesați aici pentru a găsi pașii de instalare a sistemului de operare.

Deoarece avem 3 subdomenii asociate cu un singur domeniu pe care îl avem, vom crea un certificat SSL cu wildcard. Aceasta va răspunde tuturor subdomeniilor domeniului davidmukiibi.com.

În terminalul dvs., executați:

certbot --manual --logs-dir certbot --config-dir certbot --work-dir certbot --preferred-challenges dns certonly - server https://acme-v02.api.letsencrypt.org/directory --email adresa dvs. de e-mail -d „* .davidmukiibi.com”
Înlocuiți „adresa dvs. de e-mail” din comanda de mai sus cu propria adresă de e-mail.

Urmați instrucțiunile de pe ecran pentru a furniza certificatul SSL cu caracter comod al domeniului dvs. Când ajungeți la promptul care spune:

Vă rugăm să implementați o înregistrare DNS TXT sub numele
_acme-challenge.erpnext.davidmukiibi.com cu următoarea valoare: 
„Davidmukiibi.com” ar trebui să fie propriul nume de domeniu

Accesați tabloul de bord al domeniului dvs. și creați o înregistrare „txt” pentru _acme-challenge.erpnext.davidmukiibi.com și completați valoarea dată pe terminalul dvs. de certbot.

NOTĂ: „davidmukiibi.com” ar trebui să fie propriul nume de domeniu
SSL TXT provocare acme
Dă-i un minut sau două după crearea înregistrării respective

Reveniți la terminal și apăsați Enter pe tastatura dvs. pentru a continua procesul de furnizare a certificatelor.

Motivul pentru care trebuie să aștepți este că uneori este nevoie de mai mult timp pentru a se propaga, prin urmare, certbot nu va reuși la furnizare și va trebui să repetați întregul proces, din nou.

Când s-a terminat totul, certbot va fi creat un director „cerbot” în directorul dvs. de lucru curent. Și ieșirea pe ecran vă va direcționa către locul în care se află certificatul SSL împreună cu cele 2 fișiere de import de care avem nevoie, adică fișierele cert.pem și privkey.pem. În timp ce se află în directorul cu fișierele * .pem, executați:

pisica cert.pem | bază64 | pbcopy

Aceasta codifică cert.pem la base64 și copiază rezultatul codat cert.pem în clipboard.

Întoarceți-vă la fișierul secrets.yaml și lipiți-l în valoarea tls.crt:

secrets.yaml

Alerga:

pisica privkey.pem | bază64 | pbcopy

pentru a codifica privkey.pem și a lipi rezultatul ca valoare a tls.key: în fișierul secrets.yaml.

Comenzile: „cat cert.pem | bază64 | pbcopy ”și„ pisica privkey.pem | bază64 | pbcopy ”base64 codifică fișierele privkey.pem și cert.pem și copiază rezultatul în același timp. Deci nu veți avea nicio ieșire pe terminalul dvs., dar dacă ctrl + v sau cmd + v într-un editor de text, veți vedea rezultatul codat.

Cu secrets.yaml populat ca mai sus, rulați:

kubectl crea -f secrete.yaml

Aceasta va crea o resursă kubernetes de tip secret pe care resursa noastră de intrare o va folosi pentru terminarea SSL a.k.a navigare sigură folosind HTTPS.

Fotografie de Mimi Thian pe Unsplash

Putem acum să răsfoim browserele noastre web și să ne îndreptăm către frontend.davidmukiibi.com pentru a verifica aplicația noastră.

Observați cum se redirecționează automat către HTTPS? Aceasta este magia care vine cu utilizarea controlerului de intrare nginx.

Și acolo îl ai. În cele din urmă, a găzduit o aplicație arhitectură pe trei niveluri pe Google Kubernetes Engine.

Continuați și ștergeți resursele pe care tocmai le-ați creat dacă nu mai aveți nevoie de ele, deoarece acestea vor fi facturate de Google Cloud și încă nu sunt utilizate.

Pentru a șterge clusterul și toate resursele create anterior, executați:

grupurile de containere gcloud șterg $ CLUSTER

Țipete speciale lui John, care a pregătit întreaga cerere.

Urmăriți comenzile docker care vă vor simplifica fluxul de lucru docker real rapid din acest articol pe care l-am creat împreună.

Nu ezitați să sugerați modificări sau adăugări la cunoștințele împărtășite aici. Puteți accesa, de asemenea, o discuție prin Twitter sau LinkedIn.