🥇Kubernetes Guide Deel 1: Uwendungen, Mikroservicer a Container

Op eiser Ufro huet den Habr en Hub erstallt Kubernetes a mir si frou déi éischt Verëffentlechung dran ze setzen. Abonnéieren!

Kubernetes ass einfach. Firwat bezuelen Banken mir vill Sue fir an dësem Beräich ze schaffen, während jidderee kann dës Technologie an nëmmen e puer Stonnen beherrschen?

Wann Dir Zweiwel datt Kubernetes sou séier ka geléiert ginn, proposéieren ech Iech selwer ze probéieren. Nämlech, nodeems Dir dëst Material beherrscht hutt, kënnt Dir eng Applikatioun op Basis vu Mikroservicer an engem Kubernetes Cluster lafen. Ech kann dat garantéieren, well et ass genee déi selwecht Methodik déi hei benotzt gëtt, datt ech eise Clienten léieren mat Kubernetes ze schaffen. Wat mécht dëse Guide anescht wéi anerer? Tatsächlech ginn et vill Saachen. Also, déi meescht vun dëse Materialien fänken un mat enger Erklärung vun einfache Saachen - d'Konzepter vu Kubernetes an d'Features vum Kommando kubectl. D'Auteuren vun dëse Materialien huelen un datt hir Lieser mat Applikatiounsentwécklung, Mikroservicer an Docker Container vertraut sinn. Mir ginn deen anere Wee. Als éischt wäerte mir schwätzen iwwer wéi eng Applikatioun baséiert op Mikroservicer op engem Computer lafen. Da kucke mir Containerbilder fir all Mikroservice ze bauen. An duerno wäerte mir Kubernetes kennen léieren a kucken wéi eng Applikatioun baséiert op Mikroservicer an engem Cluster dee vu Kubernetes geréiert gëtt.

Dës Approche, mat enger gradueller Approche fir Kubernetes, gëtt d'Tiefe vum Verständnis vun deem wat geschitt ass, wat fir déi duerchschnëttlech Persoun néideg ass fir ze verstoen wéi einfach alles an Kubernetes funktionnéiert. Kubernetes ass sécher eng einfach Technologie, virausgesat datt déi, déi se léiere wëllen, wësse wou a wéi se benotzt gëtt.

Elo, ouni weider Ado, loosst eis ufänken a schwätzen iwwer d'Applikatioun mat där mir wäerte schaffen.

Experimentell Applikatioun

Eis Applikatioun wäert nëmmen eng Funktioun ausféieren. Et hëlt ee Saz als Input, duerno, mat Hëllef vun Textanalyseinstrumenter, mécht et Sentimentanalyse vun dësem Saz, kritt eng Bewäertung vun der emotionaler Haltung vum Auteur vum Saz zu engem bestëmmten Objet.

Dëst ass wéi d'Haaptfenster vun dëser Applikatioun ausgesäit.

Webapplikatioun fir Sentimentanalyse vun Texter

Aus enger technescher Siicht besteet d'Applikatioun aus dräi Mikroservicer, déi jidderee e spezifesche Set vu Probleemer léist:

SA-Frontend ass en Nginx Webserver deen statesch React Dateien servéiert.
SA-WebApp ass eng Webapplikatioun geschriwwen op Java déi Ufroe vum Frontend veraarbecht.
SA-Logic ass eng Python Applikatioun déi Sentimentanalyse op Text ausféiert.

Et ass wichteg ze bemierken datt Mikroservicer net isoléiert existéieren. Si implementéieren d'Iddi vun der "Trennung vu Verantwortung", awer gläichzäiteg musse se mateneen interagéieren.

Date fléisst an der Applikatioun

Am Diagramm uewendriwwer kënnt Dir déi nummeréiert Etappe vum System gesinn, illustréiert d'Datestroum an der Applikatioun. Loosst eis se kucken:

De Browser freet eng Datei vum Server index.html (wat am Tour de React Applikatiounspaket erofluet).
De Benotzer interagéiert mat der Applikatioun, dëst verursaacht en Opruff un d'Fréijoer-baséiert Webapplikatioun.
D'Webapplikatioun schéckt d'Ufro fir Textanalyse un d'Python-Applikatioun weider.
D'Python Applikatioun mécht Sentimentanalyse vum Text a gëtt d'Resultat als Äntwert op d'Ufro zréck.
D'Fréijoer Applikatioun schéckt eng Äntwert op d'React Applikatioun (déi am Tour d'Resultat vun der Textanalyse dem Benotzer weist).

De Code fir all dës Uwendungen ka fonnt ginn hei. Ech recommandéieren Iech dëse Repository fir Iech selwer elo ze kopéieren, well et vill interessant Experimenter domat virun eis sinn.

Lafen eng Mikroservicer-baséiert Applikatioun op Ärer lokaler Maschinn

Fir datt d'Applikatioun funktionnéiert, musse mir all dräi Mikroservicer starten. Loosst eis mat der léifste vun hinnen all ufänken - d'Front-End Applikatioun.

▍ Setzt React fir lokal Entwécklung op

Fir eng React Applikatioun auszeféieren, musst Dir d'Node.js Plattform an NPM op Ärem Computer installéieren. Wann Dir all dëst installéiert hutt, benotzt den Terminal fir an Äre Projet Dossier ze navigéieren sa-frontend a lafen de folgende Kommando:

npm install

Andeems Dir dëse Kommando am Dossier leeft node_modules d'Ofhängegkeete vun der React Applikatioun ginn gelueden, records vun deenen an der Datei sinn package.json. Wann d'Ofhängegkeeten am selwechten Dossier erofgeluede ginn, fuert de folgende Kommando:

npm start

Dat ass alles. Elo leeft d'React Applikatioun, Dir kënnt et zougräifen andeems Dir op déi folgend Adress an Ärem Browser gitt: localhost:3000. Dir kënnt eppes a sengem Code änneren. Dir gesitt direkt den Effekt vun dësen Ännerungen am Browser. Dëst ass méiglech duerch de sougenannte "waarm" Ersatz vu Moduler. Dëst mécht Front-End Entwécklung eng einfach an agreabel Erfahrung.

▍ Eng React Applikatioun fir d'Produktioun virbereeden

Fir den Zweck tatsächlech eng React Applikatioun ze benotzen, musse mir et an eng Rei vu statesche Dateien konvertéieren a se u Clienten servéieren mat engem Webserver.

Fir d'React Applikatioun ze bauen, erëm mam Terminal ze benotzen, navigéiert an den Dossier sa-frontend a lafen de folgende Kommando:

npm run build

Dëst wäert e Verzeechnes am Projet Dossier erstellen build. Et enthält all statesch Dateien déi néideg sinn fir datt d'React Applikatioun funktionnéiert.

▍ Déngscht statesch Dateien mat Nginx

Als éischt musst Dir den Nginx Webserver installéieren a lafen. et ass Dir kënnt et eroflueden an Instruktioune fannen wéi Dir se installéiert an ausféiert. Da musst Dir den Inhalt vum Dossier kopéieren sa-frontend/build an den Dossier [your_nginx_installation_dir]/html.

Mat dëser Approche ass d'Datei generéiert wärend dem Bauprozess vun der React Applikatioun index.html wäert sinn um [your_nginx_installation_dir]/html/index.html. Dëst ass d'Datei, déi als Standard den Nginx-Server produzéiert wann Dir et zougitt. De Server ass konfiguréiert fir um Hafen ze lauschteren 80, awer et kann personaliséiert ginn wéi Dir braucht andeems Dir d'Datei ännert [your_nginx_installation_dir]/conf/nginx.conf.

Elo öffnen Äre Browser a gitt op localhost:80. Dir gesitt d'React Applikatioun Säit.

Reaktioun Applikatioun zerwéiert vum Nginx Server

Wann Dir elo eppes an den Terrain gitt Type your sentence an Press de Knäppchen Send - näischt wäert geschéien. Awer wann Dir d'Konsole kuckt, kënnt Dir Fehlermeldungen do gesinn. Fir ze verstoen wou genau dës Feeler optrieden, loosst eis den Applikatiounscode analyséieren.

▍Front-End Applikatioun Code Analyse

Huelt e Bléck op de Fichier Code App.js, Mir kënne gesinn datt de Knäppchen dréckt Send rifft eng Method analyzeSentence(). De Code fir dës Method gëtt ënnendrënner uginn. Notéiert w.e.g. datt fir all Zeil déi e Kommentar vum Formulaire huet # Номер, et gëtt eng Erklärung ënner dem Code. Mir analyséieren aner Code Fragmenter an déi selwecht Manéier.

analyzeSentence() {
    fetch('http://localhost:8080/sentiment', {  // #1
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
                       sentence: this.textField.getValue()})// #2
    })
        .then(response => response.json())
        .then(data => this.setState(data));  // #3
}

1. D'URL op déi d'POST Ufro gemaach gëtt. Et gëtt ugeholl datt et eng Applikatioun op dëser Adress ass, déi esou Ufroe erwaart.

2.D'Ufro Kierper un d'Applikatioun geschéckt. Hei ass e Beispill Ufro Kierper:

{
    sentence: "I like yogobella!"
}

3.Wann eng Äntwert op eng Ufro kritt gëtt, gëtt den Zoustand vun der Komponent aktualiséiert. Dëst bewierkt datt d'Komponente nei gemaach gëtt. Wa mir Daten kréien (dat ass e JSON-Objet deen d'Inputdaten an de berechenten Textpartitur enthält), wäerte mir de Komponent ausginn Polarity, well déi entspriechend Konditiounen erfëllt ginn. Dëst ass wéi mir d'Komponente beschreiwen:

const polarityComponent = this.state.polarity !== undefined ?
    <Polarity sentence={this.state.sentence} 
              polarity={this.state.polarity}/> :
    null;

De Code schéngt ganz gutt ze schaffen. Wat ass falsch mat dësem, iwwerhaapt? Wann Dir ugeholl datt op der Adress, op déi d'Applikatioun probéiert eng POST-Ufro ze schécken, nach näischt ass, wat dës Ufro akzeptéiere kann a veraarbecht, da sidd Dir absolut richteg. Nämlech fir Ufroen ze veraarbecht, déi am http://localhost:8080/sentiment, mir mussen eng Webapplikatioun op Basis vum Fréijoer lafen.

Mir brauchen eng Fréijoersapplikatioun déi eng POST Ufro akzeptéiere kann

▍ Eng Fréijoer-baséiert Webapplikatioun opsetzen

Fir eng Fréijoersapplikatioun z'installéieren, braucht Dir JDK8 a Maven a richteg konfiguréiert Ëmfeldvariablen. Wann Dir dëst alles installéiert hutt, kënnt Dir weider un eisem Projet schaffen.

▍ Eng Applikatioun an eng Jar Datei packen

Navigéiert, mat engem Terminal, an den Dossier sa-webapp a gitt de folgende Kommando:

mvn install

Nodeems Dir dëse Kommando am Dossier leeft sa-webapp e Verzeechnes gëtt erstallt target. Dëst ass wou d'Java Applikatioun lokaliséiert gëtt, verpackt an enger Jar Datei, representéiert vun der Datei sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Lafen eng Java Applikatioun

Gitt an den Dossier target a lafen d'Applikatioun mam folgendem Kommando aus:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

E Feeler geschitt beim Ausféiere vun dësem Kommando. Fir et ze fixéieren, kënne mir d'Ausnahmsdetailer an de Stack Trace Daten analyséieren:

Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"

Fir eis ass dat wichtegst hei d'Ernimmung vun der Onméiglechkeet d'Bedeitung ze klären sa.logic.api.url. Loosst eis de Code analyséieren an deem de Feeler geschitt.

▍Java Applikatioun Code Analyse

Hei ass de Code Snippet wou de Feeler geschitt.

@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
    @Value("${sa.logic.api.url}")    // #1
    private String saLogicApiUrl;
    @PostMapping("/sentiment")
    public SentimentDto sentimentAnalysis(
        @RequestBody SentenceDto sentenceDto) 
    {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(
                saLogicApiUrl + "/analyse/sentiment",    // #2
                sentenceDto, SentimentDto.class)
                .getBody();
    }
}

An SentimentController et gëtt e Feld saLogicApiUrl. Säi Wäert gëtt vun der Immobilie spezifizéiert sa.logic.api.url.
Linn saLogicApiUrl concatenates mam Wäert /analyse/sentiment. Zesummen bilden se d'Adress fir en Uruff un de Mikroservice ze maachen deen Textanalyse mécht.

▍Set e Besëtz Wäert

Am Fréijoer ass d'Standardquell vun Immobiliewäerter eng Datei application.properties, déi op sa-webapp/src/main/resources. Awer seng Notzung ass net deen eenzege Wee fir Immobiliewäerter ze setzen. Dëst kann och mat dem folgenden Kommando gemaach ginn:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL

De Wäert vun dëser Immobilie soll op d'Adress vun eiser Python Applikatioun weisen.

Andeems Dir et konfiguréiert, soen mir d'Fréijoer Webapplikatioun wou et muss goen fir Textanalyseufroen auszeféieren.

Fir eist Liewen net ze komplizéiere wäerte mir décidéieren datt d'Python Applikatioun verfügbar ass localhost:5000 a loosst eis probéieren et net ze vergiessen. Als Resultat wäert de Kommando fir d'Fréijoersapplikatioun ze starten esou ausgesinn:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000

Eise System fehlt eng Python Applikatioun

Elo alles wat mir maache mussen ass d'Python Applikatioun ausféieren an de System funktionnéiert wéi erwaart.

▍ Eng Python Applikatioun opsetzen

Fir eng Python Applikatioun auszeféieren, musst Dir Python 3 a Pip installéiert hunn, an déi entspriechend Ëmfeldvariablen musse richteg agestallt ginn.

▍ Ofhängegkeeten installéieren

Gitt an Äre Projet Dossier sa-logic/sa a lafen déi folgend Kommandoen:

python -m pip install -r requirements.txt
python -m textblob.download_corpora

▍Start d'Applikatioun

Nodeems Dir d'Ofhängegkeeten installéiert hutt, si mir prett fir d'Applikatioun auszeféieren:

python sentiment_analysis.py

Nodeems Dir dëse Kommando ausgefouert hutt, wäerte mir déi folgend soen:

* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

Dëst bedeit datt d'Applikatioun leeft a waart op Ufroe bei localhost:5000/

▍Code Fuerschung

Loosst eis de Python Applikatiounscode kucken fir ze verstoen wéi et op Ufroe reagéiert:

from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__)                                   #1
@app.route("/analyse/sentiment", methods=['POST'])      #2
def analyse_sentiment():
    sentence = request.get_json()['sentence']           #3
    polarity = TextBlob(sentence).sentences[0].polarity #4
    return jsonify(                                     #5
        sentence=sentence,
        polarity=polarity
    )
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)                #6

En Objet initialiséieren Flask.
Eng Adress spezifizéieren fir POST Ufroen ze maachen.
Eng Immobilie zréckzéien sentence vum Ufro Kierper.
Initialiséiere vun engem anonymen Objet TextBlob a kritt de Wäert polarity fir den éischte Saz am Kierper vun der Ufro kritt (an eisem Fall ass dëst deen eenzege Saz fir Analyse geschéckt).
Retour eng Äntwert, deem säi Kierper den Text vum Saz an de berechent Indikator dofir enthält polarity.
Lancéiere eng Flask Applikatioun, déi verfügbar ass um 0.0.0.0:5000 (Dir kënnt et och zougräifen mat enger Konstruktioun vun der Form localhost:5000).

D'Mikroservicer, déi d'Applikatioun ausmaachen, lafen elo. Si sinn ofgestëmmt fir mateneen ze interagéieren. Dëst ass wéi d'Applikatiounsdiagramm an dëser Etapp vun der Aarbecht ausgesäit.

All Mikroservicer, déi d'Applikatioun ausmaachen, ginn an d'Aarbechtskonditioun bruecht

Elo, ier Dir weider geet, öffnen Är React Applikatioun an engem Browser a probéiert e Saz mat deem ze analyséieren. Wann alles richteg gemaach ass - nodeems Dir de Knäppchen dréckt Send Dir gesitt d'Analyseresultater ënner dem Textfeld.

An der nächster Sektioun schwätze mir iwwer wéi mir eis Mikroservicer an Docker Container lafen. Dëst ass néideg fir d'Applikatioun virzebereeden fir op de Kubernetes Cluster ze lafen.

Docker Container

Kubernetes ass e System fir d'Deployment, d'Skaléierung an d'Gestioun vu containeriséierten Uwendungen ze automatiséieren. Et gëtt och e "Containerorchestrator" genannt. Wann Kubernetes mat Container schafft, da musse mir ier Dir dëse System benotzt, fir d'éischt dës Container ze kréien. Awer als éischt schwätze mer iwwer wat Container sinn. Vläicht déi bescht Äntwert op d'Fro wat et ass, kann an fonnt ginn Dokumentatioun an Docker:

E Container-Image ass e liicht, selbstännegt, ausféierbart Pak, dat eng Applikatioun enthält, déi alles enthält, wat néideg ass fir se auszeféieren: Applikatiounscode, Runtime-Ëmfeld, Systemtools a Bibliothéiken, an Astellungen. Containeriséiert Programmer kënnen an Ëmfeld benotzt ginn. Linux и Windows, an si wäerten ëmmer op déiselwecht Manéier funktionéieren, onofhängeg vun der Infrastruktur.

Dëst bedeit datt Container op all Computer lafen kënnen, och Produktiounsserveren, an d'Applikatiounen, déi an hinnen enthale sinn, funktionnéieren d'selwecht an all Ëmfeld.

Fir d'Features vu Container ze entdecken an se mat anere Weeër ze vergläichen fir Uwendungen ze lafen, kucke mer e Beispill fir eng React Applikatioun mat enger virtueller Maschinn an engem Container ze déngen.

▍ Déngscht statesch Dateie vun enger React Applikatioun mat enger virtueller Maschinn

Probéiert de Service vu statesche Dateien mat virtuelle Maschinnen ze organiséieren, wäerte mir déi folgend Nodeeler begéinen:

Ineffizient Notzung vu Ressourcen, well all virtuell Maschinn e vollwäertege Betribssystem ass.
Plattform Ofhängegkeet. Wat op engem lokalen Computer funktionnéiert, funktionnéiert vläicht net op engem Produktiounsserver.
Lues a ressourceintensiv Skaléierung vun enger virtueller Maschinn-baséierter Léisung.

Nginx Webserver servéiert statesch Dateien op enger virtueller Maschinn

Wann Container benotzt gi fir en ähnleche Problem ze léisen, dann, am Verglach mat virtuelle Maschinnen, kënnen déi folgend Stäerkten bemierkt ginn:

Effizient Notzung vu Ressourcen: Schafft mam Betribssystem mat Docker.
Plattform onofhängeg. E Container, deen en Entwéckler op sengem Computer lafen kann, funktionnéiert iwwerall.
Liichtgewiicht Détachement duerch d'Benotzung vun Bildschichten.

Nginx Webserver servéiert statesch Dateien déi an engem Container lafen

Mir verglach nëmmen virtuell Maschinnen a Container op e puer Punkten, awer och dëst ass genuch fir e Gefill fir d'Stäerkte vu Container ze kréien. et ass Dir kënnt Detailer iwwer Docker Container fannen.

▍ E Containerbild fir eng React Applikatioun bauen

De Basisbausteen vun engem Docker Container ass d'Datei Dockerfile. Am Ufank vun dëser Datei gëtt e Rekord vun der Basisbild vum Container gemaach, da gëtt et eng Sequenz vun Instruktiounen, déi uginn wéi e Container erstallt deen d'Bedierfnesser vun enger bestëmmter Applikatioun entsprécht.

Ier mer ufänken mat der Datei ze schaffen Dockerfile, loosst eis drun erënneren wat mir gemaach hunn fir d'React Applikatiounsdateien ze preparéieren fir op den Nginx Server eropzelueden:

Bauen e React Applikatiounspaket (npm run build).
Den Nginx Server starten.
Verzeechnes Inhalt kopéieren build vum Projet Dossier sa-frontend an de Server Dossier nginx/html.

Hei drënner kënnt Dir d'Parallelen tëscht engem Container erstellen an den uewe genannte Schrëtt gesinn op Ärem lokalen Computer.

▍D'Dockerfile fir d'SA-Frontend Applikatioun virbereeden

D'Instruktioune, déi an Dockerfile fir Uwendung SA-Frontend, besteet aus nëmmen zwou Equippen. De Fakt ass datt d'Nginx Entwécklungsteam eng Basis virbereet huet e Bild fir Nginx, déi mir benotze fir eist Bild ze kreéieren. Dëst sinn déi zwee Schrëtt déi mir musse beschreiwen:

D'Basis vum Bild soll den Nginx Bild sinn.
Dossier Inhalt sa-frontend/build muss an d'Bild Dossier kopéiert ginn nginx/html.

Wann Dir vun dëser Beschreiwung op d'Datei gitt Dockerfile, da gesäit et esou aus:

FROM nginx
COPY build /usr/share/nginx/html

Wéi Dir gesitt, ass alles hei ganz einfach, an den Inhalt vun der Datei gëtt souguer ganz liesbar a verständlech. Dëse Fichier seet de System d'Bild ze huelen nginx mat alles wat schonn dran ass, a kopéiert den Inhalt vum Verzeichnis build an den Dossier nginx/html.

Hei hutt Dir vläicht eng Fro iwwer wéi ech weess wou genau Dir musst Dateien aus dem Dossier kopéieren build, also wou de Wee hierkënnt /usr/share/nginx/html. Tatsächlech gëtt et hei och näischt komplizéiert. De Fakt ass datt déi relevant Informatioun ka fonnt ginn Beschreiwung Bild.

▍ D'Bild bauen an an de Repository eroplueden

Ier mir mat dem fäerdege Bild kënne schaffen, musse mir et an de Bildrepository drécken. Fir dëst ze maachen, benotze mir déi gratis Cloud Image Hosting Plattform Docker Hub. Op dëser Etapp vun der Aarbecht musst Dir déi folgend maachen:

Installéieren Docker.
Registréiert Iech op der Docker Hub Websäit.
Mellt Iech op Äre Kont un andeems Dir de folgende Kommando am Terminal leeft:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Elo musst Dir den Terminal benotzen fir an de Verzeichnis ze goen sa-frontend a lafen de folgende Kommando do:

docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .

Hei a weider an ähnlechen Kommandoen $DOCKER_USER_ID soll mat Ärem Docker Hub Benotzernumm ersat ginn. Zum Beispill kann dësen Deel vum Kommando esou ausgesinn: rinormaloku/sentiment-analysis-frontend.

An dësem Fall kann dëse Kommando verkierzt ginn andeems Dir et ewechhuelt -f Dockerfile, well dës Datei schonn am Dossier existéiert an deem mir dëse Kommando ausféieren.

Fir de fäerdege Bild an de Repository ze schécken, brauche mir de folgende Kommando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Nodeems Dir se ofgeschloss hutt, kontrolléiert d'Lëscht vun Äre Repositories op Docker Hub fir ze verstoen ob den Eroplueden vum Bild an d'Cloudlagerung erfollegräich war.

▍Behälter lafen

Elo kann jiddereen d'Bild eroflueden a lafen, bekannt als $DOCKER_USER_ID/sentiment-analysis-frontend. Fir dëst ze maachen, musst Dir déi folgend Sequenz vun Kommandoen ausféieren:

docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

Elo leeft de Container, mir kënne weider schaffen andeems mir aner Biller kreéieren déi mir brauchen. Awer ier mer weidergoen, loosst eis den Design verstoen 80:80, déi am Bildstartbefehl erschéngt a kann duerchernee schéngen.

Éischt Nummer 80 - dëst ass d'Hostportnummer (dat ass de lokale Computer).
Zweet Zuel 80 ass den Hafen vum Container un deen d'Demande weidergeleet soll ginn.

Betruecht déi folgend Illustratioun.

Port Forwarding

De System redirects Ufroe vum Hafen <hostPort> an den Hafen <containerPort>. Dat ass, Zougang zum Hafen 80 Computer gëtt op den Hafen ëmgeleet 80 Container.

Zënter dem Hafen 80 op de lokalen Computer opgemaach, da kënnt Dir op d'Applikatioun vun dësem Computer op localhost:80. Wann Äre System den Docker net ënnerstëtzt, kann d'Applikatioun op enger Docker virtueller Maschinn lafen, d'Adress vun där ausgesäit <docker-machine ip>:80. Fir d'IP Adress vun der Docker virtueller Maschinn erauszefannen, kënnt Dir de Kommando benotzen docker-machine ip.

Zu dësem Zäitpunkt, nodeems Dir de Front-End Applikatioun Container erfollegräich lancéiert hutt, sollt Dir fäeg sinn seng Säit am Browser opzemaachen.

▍D'.dockerignore Datei

Sammelen eng Applikatioun Bild SA-Frontend, mir konnten feststellen datt dëse Prozess extrem lues ass. Dëst geschitt well de Kontext vum Bildbau muss un den Docker Daemon geschéckt ginn. De Verzeichnis deen de Baukontext representéiert gëtt als lescht Argument vum Kommando uginn docker build. An eisem Fall gëtt et e Punkt um Enn vun dësem Kommando. Dëst verursaacht datt déi folgend Struktur am Baukontext abegraff ass:

sa-frontend:
|   .dockerignore
|   Dockerfile
|   package.json
|   README.md
+---build
+---node_modules
+---public
---src

Awer vun all den Dossieren déi hei präsent sinn, brauche mir nëmmen den Dossier build. Alles anescht ze lueden ass eng Verschwendung vun Zäit. Dir kënnt de Bau beschleunegen andeems Dir Docker seet wéi eng Verzeechnes ze ignoréieren. Et ass fir dëst ze maachen datt mir de Fichier brauchen .dockerignore. Dir, wann Dir mat der Datei kennt .gitignore, wäert d'Struktur vun dësem Fichier wahrscheinlech vertraut schéngen. Et listet Verzeichnisser déi de Bildbausystem ignoréiere kann. An eisem Fall gesäit den Inhalt vun dëser Datei esou aus:

node_modules
src
public

Fichier .dockerignore muss am selwechten Dossier wéi d'Datei sinn Dockerfile. Elo baut d'Bild eng Saach vu Sekonnen.

Loosst eis elo um Bild fir d'Java Applikatioun schaffen.

▍ E Containerbild fir eng Java Applikatioun bauen

Dir wësst wat, Dir hutt schonn alles geléiert wat Dir wësse musst fir Containerbilder ze kreéieren. Dofir wäert dës Rubrik ganz kuerz sinn.

De Fichier opmaachen Dockerfiledéi am Projet Dossier ass sa-webapp. Wann Dir den Text vun dësem Fichier liest, gesitt Dir nëmmen zwee nei Konstruktiounen dran, ugefaange mat de Schlësselwieder ENV и EXPOSE:

ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080

Schlësselwuert ENV Erlaabt Iech Ëmfeldvariablen an Docker Container ze deklaréieren. Besonnesch an eisem Fall erlaabt et Iech eng URL ze spezifizéieren fir Zougang zu der API vun der Applikatioun déi Textanalyse mécht.

Schlësselwuert EXPOSE erlaabt Iech Docker ze soen fir e Port opzemaachen. Mir wäerten dësen Hafen benotzen wann Dir d'Applikatioun leeft. Hei kënnt Dir feststellen, datt am Dockerfile fir Uwendung SA-Frontend et gëtt keen esou Kommando. Dëst ass nëmme fir Dokumentatiounszwecker, dat heescht, dës Konstruktioun ass geduecht fir deen dee liest Dockerfile.

D'Bild bauen an et an de Repository drécken gesäit genau d'selwecht aus wéi am virege Beispill. Wann Dir nach net ganz zouversiichtlech an Äre Fäegkeeten sidd, kënnen déi entspriechend Kommandoen an der Datei fonnt ginn README.md am Dossier sa-webapp.

▍ Bauen vun engem Containerbild fir eng Python Applikatioun

Wann Dir den Inhalt vun der Datei kuckt Dockerfile am Dossier sa-logic, da fannt Dir do näischt Neies fir Iech. D'Befehle fir d'Bild opzebauen an an de Repository ze schécken, sollten Iech och scho vertraut sinn, awer, wéi mat eisen aneren Uwendungen, kënnen se an der Datei fonnt ginn README.md am Dossier sa-logic.

▍Containeriséierter Uwendungen testen

Kënnt Dir eppes vertrauen wat Dir net getest hutt? Ech kann och net. Loosst eis eis Container testen.

Loosst eis den Applikatiounscontainer starten sa-logic a konfiguréieren et fir um Hafen ze lauschteren 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Loosst eis den Applikatiounscontainer starten sa-webapp a konfiguréieren et fir um Hafen ze lauschteren 8080. Zousätzlech musse mir den Hafen konfiguréieren, op deem d'Python-Applikatioun no Ufroe vun der Java-Applikatioun lauschtert andeems d'Ëmfeldvariabel ëmgeet SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

Fir ze léieren wéi Dir d'IP Adress vun engem Docker Container oder virtuell Maschinn erausfënnt, kuckt op d'Datei README.

Loosst eis den Applikatiounscontainer starten sa-frontend:

docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

Elo ass alles prett fir op d'Adress am Browser ze goen localhost:80 a probéiert d'Applikatioun.

Maacht weg datt wann Dir den Hafen geännert hutt fir sa-webapp, oder wann Dir eng Docker virtuell Maschinn leeft, musst Dir d'Datei änneren App.js aus engem Dossier sa-frontendandeems Dir d'IP Adress oder d'Portnummer an der Method änneren analyzeSentence(), Ersatz vun aktuell Informatioun amplaz vun alen Donnéeën. Duerno musst Dir d'Bild erëm zesummesetzen a benotzen.

Dëst ass wéi eis Uwendungsdiagramm elo ausgesäit.

Mikroservicer lafen a Container

Resumé: Firwat brauche mir e Kubernetes Cluster?

Mir hu just d'Dossieren iwwerpréift Dockerfile, geschwat wéi Dir Biller bauen an se an en Docker Repository drécken. Zousätzlech hu mir geléiert wéi d'Bildversammlung mat der Datei beschleunegt gëtt .dockerignore. Als Resultat lafen eis Mikroservicer elo an Docker Container. Hei hutt Dir vläicht eng komplett gerechtfäerdegt Fro iwwer firwat mir Kubernetes brauchen. Den zweeten Deel vun dësem Material gëtt op dës Fro gewidmet. An der Tëschenzäit, betruecht déi folgend Fro:
Loosst eis unhuelen datt eis Webapplikatioun fir Textanalyse weltwäit populär ginn ass. Millioune vun Demanden kommen him all Minutt. Dëst bedeit datt Mikroservicer sa-webapp и sa-logic wäert ënner enorm Laascht sinn. Wéi Skala Container Lafen Mikroservicer?

Source: will.com