Kubernetes selvstudie del 1: Programmer, mikrotjenester og containere

På vores anmodning oprettede Habr en hub Kubernetes og vi er glade for at kunne placere den første publikation i den. Abonner!

Kubernetes er nemt. Hvorfor betaler bankerne mig mange penge for at arbejde på dette område, mens alle kan mestre denne teknologi på få timer?

Hvis du tvivler på, at Kubernetes kan læres så hurtigt, foreslår jeg, at du prøver at gøre det selv. Når du har mestret dette materiale, vil du nemlig være i stand til at køre en applikation baseret på mikrotjenester i en Kubernetes-klynge. Det kan jeg garantere, for det er i samme metode, som jeg bruger her, at jeg lærer vores kunder at arbejde med Kubernetes. Hvad adskiller denne guide fra andre? Faktisk en masse ting. Så de fleste af disse materialer begynder med en forklaring af simple ting - begreberne Kubernetes og funktionerne i kommandoen kubectl. Forfatterne af disse artikler antager, at deres læser er bekendt med applikationsudvikling, mikrotjenester og Docker-containere. Vi går den anden vej. Lad os først tale om, hvordan man kører en applikation baseret på mikrotjenester på en computer. Derefter vil vi se på at bygge containerbilleder for hver mikrotjeneste. Og derefter vil vi stifte bekendtskab med Kubernetes og analysere implementeringen af ​​en applikation baseret på mikrotjenester i en klynge administreret af Kubernetes.

Denne tilgang, med en gradvis tilgang til Kubernetes, vil give den dybde af forståelse af, hvad der sker, som den gennemsnitlige person har brug for for at forstå, hvor simpelt alt er arrangeret i Kubernetes. Kubernetes er bestemt en simpel teknologi, forudsat at den, der vil mestre den, ved, hvor og hvordan den bruges.

Nu, uden videre, lad os gå i gang og tale om den applikation, vi skal arbejde med.

Eksperimentel app

Vores applikation vil kun udføre én funktion. Den tager, som input, én sætning, hvorefter den ved hjælp af tekstanalyseværktøjer udfører en sentimentanalyse af denne sætning og opnår en vurdering af sætningsforfatterens følelsesmæssige holdning til et bestemt objekt.

Sådan ser hovedvinduet i denne applikation ud.

Sentiment analyse webapplikation

Fra et teknisk synspunkt består applikationen af ​​tre mikrotjenester, som hver løser et bestemt sæt opgaver:

• SA-Frontend er en Nginx-webserver, der serverer statiske React-filer.
• SA-WebApp er en webapplikation skrevet i Java, der håndterer anmodninger fra frontend.
• SA-Logic er en Python-applikation, der udfører tekstsentimentanalyse.

Det er vigtigt at bemærke, at mikrotjenester ikke eksisterer isoleret. De implementerer ideen om "adskillelse af opgaver", men de skal samtidig interagere med hinanden.

Datastrømme i applikationen

I ovenstående diagram kan du se de nummererede trin i systemet, der illustrerer datastrømmene i applikationen. Lad os opdele dem:

1. Browseren anmoder om en fil fra serveren index.html (som igen indlæser React app-pakken).
2. Brugeren interagerer med applikationen, dette forårsager et opkald til en webapplikation baseret på Spring.
3. Webapplikationen videresender anmodningen om at parse teksten til Python-applikationen.
4. Python-applikationen analyserer stemningen i teksten og returnerer resultatet som et svar på anmodningen.
5. Spring-applikationen sender et svar til React-applikationen (som igen viser resultatet af den parsede tekst til brugeren).

Koden til alle disse applikationer kan findes her. Jeg anbefaler, at du kopierer dette depot til dig selv lige nu, da der ligger mange interessante eksperimenter med det foran os.

Kørsel af en applikation baseret på mikrotjenester på den lokale maskine

For at applikationen skal virke, skal vi starte alle tre mikrotjenester. Lad os starte med den smukkeste af dem - front-end-applikationen.

▍Opsætning af React til lokal udvikling

For at køre en React-applikation skal du installere Node.js frameworket og NPM på din computer. Når du har installeret alt dette, skal du bruge terminalen til projektmappen sa-frontend og kør følgende kommando:

npm install

Ved at udføre denne kommando i mappen node_modules afhængighederne af React-applikationen vil blive indlæst, hvis registreringer er i filen package.json. Når du har downloadet afhængighederne i den samme mappe, skal du køre følgende kommando:

npm start

Det er alt. React-appen kører nu og kan tilgås ved at navigere til browseradressen localhost:3000. Du kan ændre noget i hans kode. Du vil straks se effekten af ​​disse ændringer i browseren. Dette er muligt takket være den såkaldte "hot" udskiftning af moduler. Takket være dette bliver frontend-udvikling til en enkel og fornøjelig oplevelse.

▍Forberedelse af en React-app til produktion

For faktisk at bruge en React-app skal vi konvertere den til et sæt statiske filer og servere dem til klienter ved hjælp af en webserver.

For at bygge React-appen, igen ved hjælp af terminalen, skal du navigere til mappen sa-frontend og kør følgende kommando:

npm run build

Dette vil oprette en mappe i projektmappen build. Den vil indeholde alle de statiske filer, der kræves for, at React-applikationen kan fungere.

▍Visning af statiske filer med Nginx

Først skal du installere og køre Nginx-webserveren. Her du kan downloade det og finde instruktioner til at installere og køre det. Derefter skal du kopiere indholdet af mappen sa-frontend/build til en mappe [your_nginx_installation_dir]/html.

Med denne tilgang genereres filen under samlingen af ​​React-applikationen index.html vil være tilgængelig kl [your_nginx_installation_dir]/html/index.html. Dette er den fil, som Nginx-serveren som standard udsteder, når den tilgår den. Serveren er konfigureret til at lytte på en port 80, men du kan tilpasse den, som du vil, ved at redigere filen [your_nginx_installation_dir]/conf/nginx.conf.

Åbn nu din browser og gå til localhost:80. Du vil se React app-siden.

React app serveret af Nginx server

Hvis du nu indtaster noget i feltet Type your sentence og tryk på knappen Send - der vil ikke ske noget. Men hvis du ser på konsollen, kan du se fejlmeddelelser der. For at forstå præcis, hvor disse fejl opstår, lad os analysere applikationskoden.

▍Analyse af koden for frontend-applikationen

Ser på filens kode App.js, kan vi se det ved at klikke på knappen Send kalder en metode analyzeSentence(). Koden til denne metode er vist nedenfor. Samtidig skal du være opmærksom på, at for hver linje, som der er en kommentar til formularen # Номер, er der en forklaring under koden. På samme måde vil vi parse andre kodefragmenter.

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. URL'en, som POST-anmodningen sendes til. Denne adresse antages at være en ansøgning, der venter på sådanne anmodninger.

2.Anmodningsorganet sendt til ansøgningen. Her er et eksempel på en anmodningstekst:

{
    sentence: "I like yogobella!"
}

3.Når et svar på en anmodning modtages, opdateres komponentens tilstand. Dette får komponenten til at gengives. Hvis vi modtager data (det vil sige et JSON-objekt, der indeholder de indtastede data og den beregnede tekstscore), vil vi udlæse komponenten Polarityså længe betingelserne er opfyldt. Sådan beskriver vi komponenten:

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

Koden ser ud til at fungere ret godt. Hvad er der overhovedet galt her? Hvis du antager, at der på den adresse, som applikationen forsøger at sende en POST-anmodning til, endnu ikke er noget, der kan acceptere og behandle denne anmodning, så vil du have fuldstændig ret. Nemlig at behandle forespørgsler, der kommer til adressen http://localhost:8080/sentiment, skal vi køre en webapplikation baseret på Spring.

Vi har brug for en forårsansøgning, der kan acceptere en POST-anmodning

▍Opsætning af en webapplikation baseret på Spring

For at kunne implementere en Spring-applikation skal du bruge JDK8 og Maven og korrekt konfigurerede miljøvariabler. Når du har installeret alt dette, kan du fortsætte arbejdet med vores projekt.

▍Packning af applikationen i en jar-fil

Naviger ved hjælp af terminalen til mappen sa-webapp og indtast følgende kommando:

mvn install

Efter at have udført denne kommando i mappen sa-webapp mappe vil blive oprettet target. Det er her Java-applikationen vil blive placeret, pakket i en jar-fil, repræsenteret af filen sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Start af en Java-applikation

Gå til mappe target og kør programmet med følgende kommando:

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

Der opstår en fejl under udførelse af denne kommando. For at begynde at rette det, kan vi parse undtagelsesdetaljerne i staksporingsdataene:

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}"

For os er det vigtigste her omtalen af ​​umuligheden af ​​at afklare meningen sa.logic.api.url. Lad os analysere koden, hvor fejlen opstår.

▍Java-applikationskodeanalyse

Her er kodestykket, hvor fejlen opstår.

@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();
    }
}

1. I SentimentController der er en mark saLogicApiUrl. Dens værdi er fastsat af ejendommen sa.logic.api.url.
2. Line saLogicApiUrl hænger sammen med værdi /analyse/sentiment. Sammen danner de en adresse til at ringe til mikroservicen, der udfører tekstanalyse.

▍Indstilling af en egenskabsværdi

I foråret er standardkilden til ejendomsværdier en fil application.properties, som kan findes på sa-webapp/src/main/resources. Men at bruge det er ikke den eneste måde at indstille ejendomsværdier på. Du kan også gøre dette med følgende kommando:

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

Værdien af ​​denne egenskab skal pege på adressen på vores Python-applikation.

Ved at konfigurere den fortæller vi Spring-webapplikationen, hvor den skal hen for at lave anmodninger om tekstparsing.

For ikke at komplicere vores liv, beslutter vi, at Python-applikationen vil være tilgængelig på localhost:5000 og prøv ikke at glemme det. Som et resultat vil kommandoen til at starte Spring-applikationen se sådan ud:

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

Vores system mangler en Python-applikation

Nu mangler vi bare at køre Python-applikationen, og systemet vil fungere som forventet.

▍Opsætning af et Python-program

For at køre en Python-applikation skal du have Python 3 og Pip installeret, og du skal have de relevante miljøvariabler indstillet korrekt.

▍Installer afhængigheder

Gå til projektmappen sa-logic/sa og kør følgende kommandoer:

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

▍App lancering

Med afhængighederne installeret er vi klar til at køre applikationen:

python sentiment_analysis.py

Efter at have udført denne kommando, får vi at vide følgende:

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

Det betyder, at applikationen kører og venter på anmodninger kl localhost:5000/

▍Kodeforskning

Lad os se på Python-applikationskoden for at forstå, hvordan den reagerer på anmodninger:

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

1. Objektinitialisering Flask.
2. Angivelse af adressen for at lave POST-anmodninger til den.
3. Hentning af en ejendom sentence fra anmodningsorganet.
4. Anonym objektinitialisering TextBlob og få værdien polarity for det første forslag modtaget i selve anmodningen (i vores tilfælde er dette det eneste forslag, der er indsendt til analyse).
5. Returnering af et svar, hvis brødtekst indeholder teksten til tilbuddet og den beregnede indikator for det polarity.
6. Lancering af Flask-applikationen, som vil være tilgængelig kl 0.0.0.0:5000 (du kan også få adgang til det ved at bruge en konstruktion af formularen localhost:5000).

Nu kører de mikrotjenester, der udgør applikationen. De er indstillet til at interagere med hinanden. Sådan ser ansøgningsdiagrammet ud på dette stadie af arbejdet.

Alle mikrotjenester, der udgør applikationen, bringes til en sund tilstand

Nu, før vi fortsætter, skal du åbne React-appen i en browser og prøve at analysere en sætning med den. Hvis alt er gjort korrekt - efter at have trykket på knappen Send du vil se analyseresultaterne under tekstboksen.

I næste afsnit vil vi tale om, hvordan man kører vores mikrotjenester i Docker-containere. Dette er nødvendigt for at forberede applikationen til at køre i Kubernetes-klyngen.

Docker containere

Kubernetes er et system til automatisering af udrulning, skalering og styring af containeriserede applikationer. Det kaldes også en "containerorkestrator". Hvis Kubernetes arbejder med containere, skal vi først anskaffe disse containere, før vi bruger dette system. Men lad os først tale om, hvad containere er. Måske kan det bedste svar på spørgsmålet om, hvad det er, findes i dokumentation til Docker:

Et containerbillede er en letvægts, selvstændig, eksekverbar pakke, der indeholder en applikation, som inkluderer alt, hvad der er nødvendigt for at køre det: applikationskode, runtime-miljø, systemværktøjer og biblioteker, indstillinger. Containeriserede programmer kan bruges i både Linux- og Windows-miljøer og vil altid fungere det samme uanset infrastrukturen.

Det betyder, at containere kan køres på enhver computer, inklusive produktionsservere, og i ethvert miljø vil applikationerne i dem fungere på samme måde.

For at udforske funktionerne i containere og sammenligne dem med andre måder at køre programmer på, lad os se på eksemplet med at betjene en React-applikation ved hjælp af en virtuel maskine og en container.

▍Visning af statiske filer fra en React-applikation ved hjælp af en virtuel maskine

Forsøger vi at organisere vedligeholdelsen af ​​statiske filer ved hjælp af virtuelle maskiner, vil vi støde på følgende ulemper:

1. Ineffektiv brug af ressourcer, da hver virtuel maskine er et komplet operativsystem.
2. Platform afhængighed. Det, der virker på en lokal computer, virker muligvis ikke på en produktionsserver.
3. Langsom og ressourcekrævende skalering af en virtuel maskine-løsning.

Nginx-webserver, der serverer statiske filer, der kører på en virtuel maskine

Hvis containere bruges til at løse et lignende problem, kan følgende styrker bemærkes i sammenligning med virtuelle maskiner:

1. Effektiv brug af ressourcer: Arbejd med operativsystemet ved hjælp af Docker.
2. Platformens uafhængighed. En container, som en udvikler kan køre på sin egen computer, vil køre hvor som helst.
3. Let udrulning gennem brug af billedlag.

Nginx-webserver, der serverer statiske filer, der kører i en container

Vi har kun sammenlignet virtuelle maskiner og containere på nogle få punkter, men selv det er nok til at få en fornemmelse af containernes styrker. Her Du kan finde detaljer om Docker-containere.

▍Opbygning af et containerbillede til en React-app

Den grundlæggende byggesten i en Docker-container er filen Dockerfile. I begyndelsen af ​​denne fil optages et basisbillede af containeren, derefter er en sekvens af instruktioner inkluderet, der angiver, hvordan man opretter en container, der opfylder en applikations behov.

Før vi begynder at arbejde med filen Dockerfile, husk, hvad vi gjorde for at forberede filerne i React-applikationen til upload til Nginx-serveren:

1. Opbygning af en React app-pakke (npm run build).
2. Start af Nginx-serveren.
3. Kopiering af indholdet af en mappe build fra projektmappe sa-frontend til servermappen nginx/html.

Nedenfor kan du se parallellerne mellem oprettelse af en container og ovenstående handlinger udført på den lokale computer.

▍Forberedelse af en Dockerfile til SA-Frontend-applikationen

Instruktioner, der skal indgå i Dockerfile til ansøgning SA-Frontend, kun består af to hold. Faktum er, at Nginx-udviklingsteamet har udarbejdet en grundlæggende billede til Nginx, som vi vil bruge til at bygge vores image. Her er de to trin, vi skal beskrive:

1. Du skal gøre Nginx-billedet til grundlaget for billedet.
2. Mappeindhold sa-frontend/build skal kopieres til billedmappen nginx/html.

Hvis vi går fra denne beskrivelse til filen Dockerfile, så ser det sådan ud:

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

Som du kan se, er alt her meget enkelt, mens indholdet af filen endda viser sig at være ret læseligt og forståeligt. Denne fil fortæller systemet at tage billedet nginx med alt det, den allerede har, og kopier indholdet af mappen build til biblioteket nginx/html.

Her har du måske et spørgsmål om, hvordan jeg ved, hvor jeg præcist skal kopiere filerne fra mappen build, altså hvor kom stien fra /usr/share/nginx/html. Faktisk er der heller ikke noget kompliceret her. Faktum er, at de relevante oplysninger kan findes i beskrivelse billede.

▍Samling af billedet og upload af det til lageret

Før vi kan arbejde med et færdigt billede, skal vi indsende det til billedlageret. For at gøre dette vil vi bruge den gratis cloud-baserede billedhostingplatform Docker Hub. På dette stadie af arbejdet skal du gøre følgende:

1. etablere Docker.
2. Tilmeld dig på Docker Hub-siden.
3. Log ind på din konto ved at køre følgende kommando i terminalen:

   docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"

Nu skal du, ved hjælp af terminalen, gå til biblioteket sa-frontend og kør følgende kommando der:

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

Her og nedenfor i lignende kommandoer $DOCKER_USER_ID skal erstattes med dit brugernavn på Docker Hub. For eksempel kan denne del af kommandoen se sådan ud: rinormaloku/sentiment-analysis-frontend.

I dette tilfælde kan denne kommando forkortes ved at fjerne fra den -f Dockerfile, da mappen, hvor vi udfører denne kommando, allerede har denne fil.

For at sende det færdige billede til depotet, har vi brug for følgende kommando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Når du har fuldført det, skal du tjekke din liste over depoter på Docker Hub for at se, om billedet blev sendt til skylageret.

▍Start af en beholder

Nu kan alle downloade og køre billedet kendt som $DOCKER_USER_ID/sentiment-analysis-frontend. For at gøre dette skal du køre følgende sekvens af kommandoer:

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

Nu kører containeren, og vi kan fortsætte med at arbejde ved at lave andre billeder, vi har brug for. Men før vi fortsætter, lad os forstå designet 80:80, som findes i kommandoen til at køre billedet og kan virke forvirrende.

• Første nummer 80 er værtens portnummer (det vil sige den lokale computer).
• Andet nummer 80 er containerens havn, som anmodningen skal omdirigeres til.

Overvej følgende illustration.

Portvideresendelse

Systemet videresender anmodninger fra havnen <hostPort> per havn <containerPort>. Det vil sige adgang til havnen 80 computeren omdirigeres til en port 80 beholder.

Siden havnen 80 åbnet på den lokale computer, kan du få adgang til programmet fra denne computer på localhost:80. Hvis dit system ikke understøtter Docker, kan du køre applikationen på en Docker virtuel maskine, hvis adresse vil se ud <docker-machine ip>:80. For at finde ud af IP-adressen på den virtuelle Docker-maskine kan du bruge kommandoen docker-machine ip.

På dette tidspunkt, når frontend-appbeholderen er blevet lanceret, bør du være i stand til at åbne dens side i en browser.

▍.dockerignore-fil

Opbygning af applikationsbilledet SA-Frontend, kunne vi bemærke, at denne proces er ekstremt langsom. Dette skyldes, at billedbygningskonteksten skal sendes til Docker-dæmonen. Det bibliotek, der repræsenterer build-konteksten, er givet som det sidste argument til kommandoen docker build. I vores tilfælde er der en prik i slutningen af ​​denne kommando. Dette resulterer i, at følgende struktur indgår i montagesammenhængen:

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

Men af ​​alle de mapper, der er til stede her, mangler vi kun en mappe build. At downloade noget andet er spild af tid. Du kan fremskynde opbygningen ved at fortælle Docker, hvilke mapper du skal ignorere. For at gøre dette har vi brug for en fil .dockerignore. Du, hvis du er bekendt med filen .gitignore, vil strukturen af ​​denne fil sandsynligvis se bekendt ud. Den viser mapper, som image build-systemet kan ignorere. I vores tilfælde ser indholdet af denne fil sådan ud:

node_modules
src
public

fil .dockerignore skal være i samme mappe som filen Dockerfile. Nu vil samlingen af ​​billedet tage et par sekunder.

Lad os nu behandle billedet til en Java-applikation.

▍Opbygning af et containerbillede til en Java-applikation

Ved du hvad, og du har allerede lært alt, hvad du behøver for at skabe containerbilleder. Derfor bliver dette afsnit meget kort.

Åbn filen Dockerfile, som ligger i projektmappen sa-webapp. Hvis du læser teksten i denne fil, vil du i den kun møde to nye konstruktioner, der begynder med nøgleord ENV и EXPOSE:

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

søgeord ENV giver dig mulighed for at erklære miljøvariabler inde i Docker-containere. Især i vores tilfælde giver det dig mulighed for at indstille en URL for at få adgang til API'en for den applikation, der udfører tekstanalyse.

søgeord EXPOSE giver dig mulighed for at bede Docker om at åbne en port. Vi vil bruge denne port, mens vi arbejder med applikationen. Her kan du se det Dockerfile til ansøgning SA-Frontend der er ingen sådan kommando. Dette er kun til dokumentationsformål, med andre ord, denne konstruktion er til læseren Dockerfile.

At bygge billedet og skubbe det til depotet ser nøjagtigt ud som det forrige eksempel. Hvis du endnu ikke er særlig sikker på dine evner, kan de tilsvarende kommandoer findes i filen README.md i mappe sa-webapp.

▍Opbygning af et containerbillede til en Python-applikation

Hvis du tager et kig på indholdet af filen Dockerfile i mappe sa-logicdu finder ikke noget nyt der. Kommandoerne til at bygge billedet og skubbe det til depotet burde også være bekendt for dig, men som det er tilfældet med vores andre applikationer, kan de findes i filen README.md i mappe sa-logic.

▍Test af containeriserede applikationer

Kan du stole på noget, du ikke har testet? Det kan jeg heller ikke. Lad os teste vores containere.

1. Lad os starte applikationsbeholderen sa-logic og konfigurer den til at lytte på en port 5050:

   docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic

2. Lad os starte applikationsbeholderen sa-webapp og konfigurer den til at lytte på en port 8080. Derudover skal vi indstille porten, som Python-applikationen vil lytte efter anmodninger fra Java-applikationen ved at omtildele miljøvariablen 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

For at lære, hvordan du finder ud af IP-adressen på en container eller Docker VM, se filen README.

Lad os starte applikationsbeholderen sa-frontend:

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

Nu er alt klar til at navigere i browseren til adressen localhost:80 og test appen.

Bemærk venligst, at hvis du ændrer porten for sa-webapp, eller hvis du kører en Docker VM, skal du redigere filen App.js fra mappe sa-frontendved at ændre IP-adressen eller portnummeret i metoden analyzeSentence()ved at erstatte aktuelle oplysninger i stedet for forældede data. Derefter skal du samle billedet igen og bruge det.

Sådan ser vores ansøgningsdiagram ud nu.

Mikrotjenester kører i containere

Resumé: hvorfor har vi brug for en Kubernetes-klynge?

Vi har lige gennemgået filerne Dockerfile, talte om, hvordan man bygger billeder og skubber dem til et Docker-lager. Derudover lærte vi, hvordan man fremskynder samlingen af ​​billeder ved hjælp af filen .dockerignore. Som følge heraf kører vores mikrotjenester nu i Docker-containere. Her har du måske et helt berettiget spørgsmål om, hvorfor vi har brug for Kubernetes. Svaret på dette spørgsmål vil blive afsat til anden del af dette materiale. Overvej i mellemtiden følgende spørgsmål:
Lad os antage, at vores webapplikation til tekstanalyse er blevet populær over hele verden. Millioner af anmodninger kommer til ham hvert minut. Det betyder, at mikrotjenester sa-webapp и sa-logic vil være under enorm stress. Hvordan skalerer man containere, der kører mikrotjenester?

Kilde: www.habr.com