🥇Guide til Kubernetes, del 1: applikationer, mikrotjenester og containere

På vores anmodning har Habr oprettet et hub Kubernetes og vi er glade for at offentliggøre den første artikel dér. Følg med!

Kubernetes er enkelt. Hvorfor betaler banker mig store beløb for arbejde inden for dette felt, når enhver kan mestre denne teknologi på blot få timer?

Hvis du er i tvivl om, at Kubernetes kan læres så hurtigt — så foreslår jeg, at du prøver det selv. Ved at lære dette materiale vil du kunne starte en applikation baseret på mikrotjenester i et Kubernetes-kluster. Det kan jeg garantere, da det er netop den metode, jeg bruger til at lære vores kunder om Kubernetes. Hvad adskiller denne vejledning fra andre? Faktisk er der mange ting. Således starter de fleste lignende materialer med at forklare enkle ting — Kubernetes-konceptet og kommandoerne til kubectl. Forfatterne til disse materialer antager, at deres læser er bekendt med applikationsudvikling, mikrotjenester og Docker-containere. Vi vil derimod tage en anden tilgang. Først vil vi fortælle, hvordan man starter en applikation baseret på mikrotjenester på en computer. Derefter ser vi på opbygningen af containerbilleder for hver mikrotjeneste. Og efter det vil vi lære om Kubernetes og gennemgå implementeringen af en applikation baseret på mikrotjenester i et kluster styret af Kubernetes.

Denne tilgang, med en gradvis tilnærmelse til Kubernetes, vil give den dybde af forståelse, som en almindelig person har brug for for at forstå, hvor enkelt alt fungerer i Kubernetes. Kubernetes er uden tvivl en simpel teknologi, forudsat at den, der ønsker at mestre den, ved hvor og hvordan den anvendes.

Nu, uden flere ord, lad os komme i gang og tale om applikationen, som vi skal arbejde med.

Eksperimentel applikation

Vores applikation vil udføre kun én funktion. Den tager et enkelt sætning som input og udfører en sentimentanalyse af denne sætning ved hjælp af tekstanalyseværktøjer og får en vurdering af forfatterens emotionelle holdning til et bestemt objekt.

Sådan ser hovedvinduet i denne applikation ud.

Webapplikation til sentimentanalyse af tekster

Set fra et teknisk perspektiv består applikationen af tre mikrotjenester, hver med sit eget sæt af opgaver:

SA-Frontend — Nginx-webserveren, der leverer statiske React-filer.
SA-WebApp — et webapplikation skrevet i Java, som behandler anmodninger fra frontenden.
SA-Logic — en Python-applikation, der analyserer tekstens tone.

Det er vigtigt at bemærke, at mikrotjenesterne ikke eksisterer i isolation. De implementerer ideen om "ansvarsadskillelse", men de skal også interagere med hinanden.

Datastreams i applikationen

I den ovennævnte skitse kan man se nummererede faser af systemets arbejde, der illustrerer datastreams i applikationen. Lad os se nærmere på dem:

Browseren anmoder serveren om en fil index.html (som, på sin side, downloader pakken med React-applikationen).
Brugeren interagerer med applikationen, hvilket fører til en anmodning til det webapplikation baseret på Spring.
Webapplikationen videresender anmodningen til Python-applikationen for at udføre tekstanalysen.
Python-applikationen analyserer tekstens tone og returnerer resultatet som svar på anmodningen.
Spring-applikationen sender svaret til React-applikationen (som igen viser resultatet af tekstanalysen til brugeren).

Koden til alle disse applikationer kan findes her. Jeg anbefaler, at du kopierer dette repository nu, da vi har mange spændende eksperimenter foran os.

Kørsel af applikation baseret på mikrotjenester på din lokale computer

For at applikationen kan køre, skal vi starte alle tre mikrotjenester. Lad os begynde med den mest fremtrædende af dem — frontend-applikationen.

▍Opsætning af React til lokal udvikling

For at køre React-applikationen skal du installere Node.js-platformen og NPM på din computer. Når du har installeret det, skal du navigere til projektmappen ved hjælp af terminalen. sa-frontend og køre følgende kommando:

npm install

Ved at køre denne kommando vil afhængighederne for React-applikationen blive downloadet til mappen node_modules som er anført i filen package.json. Når afhængighederne er downloadet, skal du køre følgende kommando i den samme mappe:

npm start

Og det er det. Nu kører React-applikationen, og du kan få adgang til den ved at gå til adressen i browseren localhost:3000. Du kan ændre noget i sin kode. Effekten af disse ændringer vil straks kunne ses i browseren. Dette er muligt takket være såkaldt "hot" module replacement. Dette gør frontend-udvikling til en enkel og behagelig opgave.

▍Forberedelse af React-applikationen til produktion

For at kunne bruge React-applikationen i praksis, skal vi konvertere den til et sæt statiske filer og servere dem til klienterne via en webserver.

For at bygge React-applikationen, skal vi igen bruge terminalen, og gå ind i mappen sa-frontend og køre følgende kommando:

npm run build

Dette vil skabe et katalog i projektmappen build. Det vil indeholde alle de statiske filer, der er nødvendige for at React-applikationen fungerer.

▍Betjening af statiske filer med Nginx

Først skal du installere og starte webserveren Nginx. Her Du kan downloade den og finde installationsvejledninger. Derefter skal du kopiere indholdet af mappen sa-frontend/build til mappen [your_nginx_installation_dir]/html.

Med denne tilgang vil filen, der genereres under bygningen af React-applikationen, index.html være tilgængelig på adressen [your_nginx_installation_dir]/html/index.html. Dette er den fil, som Nginx-serveren som standard leverer ved henvendelse til den. Serveren er indstillet til at lytte på port 80, men den kan konfigureres, som du ønsker, ved at redigere filen [your_nginx_installation_dir]/conf/nginx.conf.

Nu skal du åbne browseren og gå til adressen localhost:80. Du vil se siden af React-applikationen.

React-applikation betjent af Nginx-serveren

Hvis du nu indtaster noget i feltet Type your sentence og trykker på knappen Send — vil der ikke ske noget. Men hvis du ser i konsollen, kan du se fejlmeddelelser. For at forstå, hvor disse fejl opstår, vil vi se nærmere på applikationens kode.

▍Analyse af frontend-applikationens kode

Ved at se på koden i filen App.js, kan vi se, at når knappen Send trykkes, kaldes metoden analyzeSentence(). Koden til denne metode er angivet nedenfor. Vær opmærksom på, at hver linje, der har en kommentar som # Номер, har en forklaring angivet nedenfor koden. På samme måde vil vi analysere 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, som POST-anmodningen sendes til. Det antages, at der på denne adresse er en applikation, der venter på sådanne anmodninger.

2.Anmodningens krop, der sendes til applikationen. Her er et eksempel på anmodningens krop:

{
    sentence: "Jeg kan godt lide yogobella!"
}

3.Ved modtagelse af svaret på anmodningen opdateres komponentens tilstand. Dette forårsager, at komponenten renderes igen. Hvis vi modtager data (dvs. et JSON-objekt, der indeholder de indtastede data og den beregnede tekstvurdering), vil vi vise komponenten Polarity, når de relevante betingelser er opfyldt. Her er, hvordan vi beskriver komponenten:

const polarityComponent = this.state.polarity !== undefined ?
     :
    null;

Koden ser ud til at være funktionel. Hvad er der dog galt her? Hvis du antager, at der på den adresse, som applikationen prøver at sende POST-anmodningen til, ikke er noget, der kan modtage og behandle denne anmodning, har du helt ret. For at behandle anmodninger, der kommer til adressen http://localhost:8080/sentiment, skal vi køre en webapplikation baseret på Spring.

Vi har brug for en Spring-applikation, der kan modtage POST-anmodninger

▍Opsætning af en webapplikation baseret på Spring

For at implementere en Spring-applikation har du brug for JDK8 og Maven samt korrekt konfigurerede miljøvariabler. Når du har installeret alt dette, kan du fortsætte med at arbejde på vores projekt.

▍Pakke applikationen i en jar-fil

Naviger via terminalen til mappen sa-webapp og indtast følgende kommando:

mvn install

Efter at have kørt denne kommando, vil der i mappen sa-webapp blive oprettet et bibliotek target. Her vil Java-applikationen, pakket i en jar-fil, være repræsenteret af filen sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Kørsel af Java-applikationen

Gå til mappen target og start applikationen med følgende kommando:

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

Under udførelsen af denne kommando vil der opstå en fejl. For at begynde at løse den kan vi analysere undtagelsesoplysningerne i stack trace:

Fejl ved oprettelse af bean med navn 'sentimentController': Indsprøjtning af autowired afhængigheder mislykkedes; indlejret undtagelse er java.lang.IllegalArgumentException: Kunne ikke løse pladsholder 'sa.logic.api.url' i værdi "${sa.logic.api.url}"

For os her er det vigtigste omtalen af, at værdien ikke kan fastslås sa.logic.api.url. Lad os analysere koden, hvor fejlen opstår.

▍Analyse af Java-applikationskode

Her er fragmentet af koden, 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();
    }
}

I SentimentController er der et felt saLogicApiUrl. Dens værdi angives ved egenskaben sa.logic.api.url.
Streng saLogicApiUrl konkateneres med værdien /analyse/sentiment. Sammen danner de adressen til at udføre anmodningen til mikrotjenesten, der udfører tekstanalysen.

▍Indstilling af egenskabsværdi

I Spring er den standardkilde til egenskabsværdier filen application.properties, som kan findes på adressen sa-webapp/src/main/resources. Men dens anvendelse er ikke den eneste måde at angive egenskabsværdier på. Dette kan også gøres med en kommando af følgende slag:

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 til vores Python-applikation.

Ved at konfigurere den informerer vi webapplikationen Spring om, hvor den skal sende forespørgsler til tekstanalyse.

For ikke at komplicere vores liv, lad os beslutte, at Python-applikationen vil være tilgængelig på adressen localhost:5000 og vi forsøger at huske dette. Resultatet er, at kommandoen til at starte Spring-applikationen vil se således ud:

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

I vores system mangler Python-applikationen

Nu mangler vi bare at starte Python-applikationen, så systemet fungerer som forventet.

▍Konfiguration af Python-applikationen

For at starte Python-applikationen skal du have installeret Python 3 og Pip, og du skal have de relevante miljøvariabler korrekt indstillet.

▍Installation af afhængigheder

Naviger til projektmappen sa-logic/sa og udfør følgende kommandoer:

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

▍Start applikationen

Efter installation af afhængighederne er vi klar til at starte applikationen:

python sentiment_analysis.py

Når denne kommando er udført, vil vi blive informeret om følgende:

* Kører på http://0.0.0.0:5000/ (Tryk CTRL+C for at afslutte)

Det betyder, at applikationen er startet og venter på anmodninger på adressen localhost:5000/

▍Kodeundersøgelse

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

Initialisering af objekt Flask.
Angivelse af adresse til POST-anmodninger.
Uddragning af egenskab sentence fra anmodningskroppen.
Initialisering af anonymt objekt TextBlob og hentning af værdien polarity for den første sætning, der modtages i anmodningskroppen (i vores tilfælde er dette den eneste sætning, der sendes til analyse).
Returnering af svar, hvis krop indeholder sætningens tekst og den beregnede værdi polarity.
Start af Flask-applikationen, som vil være tilgængelig på adressen 0.0.0.0:5000 (den kan også tilgås ved at bruge en struktur som localhost:5000).

Nu er mikroservices, som applikationen består af, startet. De er indstillet til at kommunikere med hinanden. Sådan ser arkitekturen ud på dette stadium.

Alle mikroservices, som applikationen består af, er bragt i fungerende tilstand

Nu, før vi fortsætter, åbner du React-applikationen i browseren og forsøger at analysere en sætning med det. Hvis alt er gjort korrekt - efter at have trykket på knappen Send vil du se resultaterne af analysen under tekstfeltet.

I det næste afsnit vil vi tale om, hvordan vi starter vores mikroservices i Docker-containere. Dette er nødvendigt for at forberede applikationen til at køre i et Kubernetes-kluster.

Docker-containere

Kubernetes — er et system til automatisering af implementering, skalerings og styring af containeriserede applikationer. Det kaldes også en "containerorkestrator". Hvis Kubernetes arbejder med containere, skal vi først have disse containere, før vi kan bruge systemet. Men lad os først tale om, hvad containere er. Det bedste svar på spørgsmålet om, hvad de er, kan findes i dokumentationen Docker:

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

Det betyder, at containere kan køre på enhver computer, inklusive produktionsservere, og i alle miljøer vil de indkapslede applikationer fungere ens.

For at undersøge egenskaberne ved containere og sammenligne dem med andre metoder til at køre applikationer, lad os se på et eksempel med at hoste en React-applikation ved hjælp af en virtuel maskine og en container.

▍Hosting af statiske filer fra React-applikationen ved hjælp af en virtuel maskine

Når vi forsøger at organisere hosting af statiske filer ved hjælp af virtuelle maskiner, vil vi støde på følgende ulemper:

Ineffektiv ressourceudnyttelse, da hver virtuel maskine udgør et fuldt operativsystem.
Platformafhængighed. Det, der fungerer på en lokal computer, kan muligvis ikke fungere på en produktionsserver.
Langsom og ressourcekrævende skalering af løsninger baseret på virtuelle maskiner.

Webserveren Nginx, der hoster statiske filer, kørende på en virtuel maskine

Hvis man derimod anvender containere til at løse en tilsvarende opgave, kan man i forhold til virtuelle maskiner bemærke følgende styrker:

Effektiv ressourceudnyttelse: arbejde med operativsystemet via Docker.
Uafhængighed af platforme. En container, som udvikleren kan køre på sin egen computer, vil fungere overalt.
Let deployment ved hjælp af billedlag.

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

Vi har sammenlignet virtuelle maskiner og containere på blot nogle få punkter, men selv dette er tilstrækkeligt til at fornemme containeres stærke sider. Her Du kan finde detaljer om Docker-containere.

▍Bygning af en containerbillede til et React-applikation

Den grundlæggende byggesten i Docker-containeren er en fil Dockerfile. I begyndelsen af denne fil angives den grundlæggende containerbillede, og derefter inkluderes en sekvens af instruktioner, der angiver rækkefølgen for at oprette den container, der vil opfylde behovene for en bestemt applikation.

Før vi begynder at arbejde med filen Dockerfile, lad os mindes om, hvad vi gjorde for at forberede filer til React-applikationen til implementering på Nginx-serveren:

Bygning af React-applikationens pakke (npm run build).
Starten af Nginx-serveren.
Kopiering af indholdet fra mappen build fra projektmappen sa-frontend til servermappen nginx/html.

Nedenfor kan du se paralleller mellem oprettelsen af en container og de tidligere beskrevne handlinger udført på din lokale computer.

▍Forberedelse af Dockerfile til SA-Frontend-applikationen

Instruktionerne i Dockerfile til applikationen SA-Frontend, består af kun to kommandoer. Det skyldes, at gruppen af udviklere hos Nginx har forberedt et grundlæggende billede til Nginx, som vi vil bruge til at oprette vores billede. Her er de to skridt, vi skal beskrive:

Bunden af billedet skal være Nginx-billedet.
Indholdet af mappen sa-frontend/build skal kopieres til billede-mappen nginx/html.

Hvis man går fra denne beskrivelse til filen Dockerfile, vil det se sådan ud:

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

Som du kan se, er alt her meget enkelt, og indholdet af filen er endda ret læsbart og forståeligt. Denne fil fortæller systemet, at det skal tage billedet nginx med alt det, det allerede indeholder, og kopiere indholdet fra mappen build til mappen nginx/html.

Her kan du måske stille dig spørgsmålet, hvordan jeg ved, hvor filerne skal kopieres fra mappen build, altså - hvor stien kommer fra. /usr/share/nginx/htmlI virkeligheden er der heller ikke noget svært ved dette. Det er fordi, de relevante oplysninger kan findes i beskrivelsen afbild.

▍Oprettelse af afbildning og upload til repository

Før vi kan arbejde med den færdige afbildning, skal vi sende den til afbildningsrepositoryet. Til dette formål bruger vi den gratis cloudplatform til hosting af afbildninger, Docker Hub. På dette tidspunkt skal du gøre følgende:

Installer Docker.
Registrer dig på Docker Hub.
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, navigere til mappen sa-frontend og køre følgende kommando:

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

Her og 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.

Denne kommando kan desuden forkortes ved at fjerne -f Dockerfile, da denne fil allerede findes i den mappe, hvor vi kører kommandoen.

For at sende den færdige afbildning til repositoryet skal vi bruge følgende kommando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Efter at have udført den, kontroller venligst listen over dine repositories på Docker Hub for at se, om uploaden af afbildningen til cloud-lagringen var succesfuld.

▍Start af container

Nu kan alle downloade og køre afbildningen kendt som $DOCKER_USER_ID/sentiment-analysis-frontend. For at gøre dette skal du udføre følgende rækkefølge af kommandoer:

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

Nu er containeren startet, og vi kan fortsætte med at arbejde ved at oprette de andre nødvendige afbildninger. Men før vi fortsætter, lad os forstå bygningen 80:80, som findes i kommandoen til at starte afbildningen og måske virker uforståelig.

Det første tal 80 — er portnummeret på værten (det vil sige — den lokale computer).
Det andet tal 80 — er containerens port, som anmodningen skal omdirigeres til.

Lad os se på følgende illustration.

Portomdirigering

Systemet omdirigerer anmodninger fra porten <hostPort> til porten <containerPort>. Det vil sige, at anmodningen til porten 80 på computeren omdirigeres til porten 80 på containeren.

Da porten 80 er åben på den lokale computer, kan appen tilgås fra denne computer på adressen localhost:80. Hvis dit system ikke understøtter Docker, kan applikationen køres på en Docker virtuel maskine, hvis adresse vil se således ud :80. For at finde IP-adressen på den Docker virtuelle maskine, kan du bruge kommandoen docker-machine ip.

På dette stadium, efter at containeren til frontend-applikationen er startet succesfuldt, bør du have mulighed for at åbne dens side i browseren.

▍Filen .dockerignore

Når vi samler applikationsbilledet SA-Frontend, har vi bemærket, at denne proces kan være ekstremt langsom. Dette sker, fordi Docker daemon skal modtage bygge-konteksten for billedet. Mappen, der repræsenterer bygge-konteksten, angives som det sidste argument i kommandoen docker build. I vores tilfælde står der et punkt til sidst i denne kommando. Dette medfører, at følgende struktur inkluderes i bygge-konteksten:

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

Men vi har kun brug for mappen build. At lægge noget andet her er en spild af tid. Bygningen kan fremskyndes ved at angive Docker, hvilke mapper der skal ignoreres. Til dette formål har vi brug for filen .dockerignore. Hvis du er fortrolig med filen .gitignore, vil strukturen af denne fil helt sikkert se bekendt ud. Den oplister de mapper, som bygningssystemet kan ignorere. I vores tilfælde ser indholdet af denne fil således ud:

node_modules
src
public

Fil .dockerignore skal ligge i samme mappe som filen Dockerfile. Nu vil byggeprocessen tage blot få sekunder.

Lad os nu fokusere på billedet for Java-applikationen.

▍Bygning af containerbillede for Java-applikationen

Ved du hvad, du har allerede lært alt, hvad der er nødvendigt for at oprette containerbilleder. Derfor vil dette afsnit være ret kort.

Åbn filen Dockerfile, som ligger i projektmappen sa-webapp. Hvis du læser teksten i denne fil, vil du støde på to nye konstruktioner, der begynder med nøgleordene ENV og EXPOSE:

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

Nøgleordet ENV giver mulighed for at deklarere miljøvariabler inden i Docker-containere. I vores tilfælde gør det det muligt at definere URL til adgang til API'et for applikationen, der analyserer teksten.

Nøgleordet EXPOSE giver Docker besked om, at porten skal åbnes. Vi vil bruge denne port, mens vi arbejder med applikationen. Her kan man bemærke, at i Dockerfile til applikationen SA-Frontend sådan en kommando ikke findes. Det er kun nødvendigt til dokumentationsformål, med andre ord er denne konstruktion beregnet til den, der vil læse Dockerfile.

Bygning af billedet og sendingen til depotet ser nøjagtig ud som i det tidligere eksempel. Hvis du ikke er helt sikker på dine evner endnu — kan de relevante kommandoer findes i filen README.md i mappen sa-webapp.

▍Bygning af containerbillede til Python-applikation

Hvis du ser på indholdet af filen Dockerfile i mappen sa-logic, vil du ikke finde noget nyt der. Kommandoerne til at bygge billedet og sende det til depotet skal også allerede være kendt for dig, men de kan, ligesom med vores andre applikationer, findes i filen README.md i mappen 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.

Lad os starte applikationscontaineren sa-logic og konfigurere den til at lytte på porten 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Lad os starte applikationscontaineren sa-webapp og konfigurere den til at lytte på porten 8080. Derudover skal vi konfigurere den port, hvor Python-applikationen vil vente på anmodninger fra Java-applikationen, ved at ændre miljøvariablen SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

For at finde ud af, hvordan man finder IP-adressen på containeren eller Docker-virtuelt maskine — henvis til filen README.

Lad os starte applikationscontaineren sa-frontend:

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

Nu er alt klar til at gå til browseren på adressen localhost:80 og teste applikationen.

Bemærk, at hvis du har ændret porten for sa-webapp, eller hvis du arbejder med en Docker-virtuelt maskine, skal du redigere filen App.js fra mappen sa-frontend, ændre IP-adressen eller portnummeret i metoden analyzeSentence(), ved at indsætte de aktuelle oplysninger i stedet for de forældede data. Derefter skal billedet genbygges, og du skal bruge det.

Sådan ser skemaet for vores applikation nu ud.

Mikroservices kører i containere

Konklusioner: hvorfor har vi brug for et Kubernetes-kluster?

Lige nu har vi gennemgået filerne Dockerfile, talt om, hvordan man bygger billeder og sender dem til Docker-depotet. Derudover har vi lært at fremskynde opbygningen af billeder ved at bruge filen. .dockerignoreSom resultat kører vores mikrotjenester nu i Docker-containere. Her kan du have et helt berettiget spørgsmål om, hvorfor vi skal bruge Kubernetes. Svaret på dette spørgsmål vil blive behandlet i den anden del af dette materiale. Men for nu, overvej følgende spørgsmål:
Antag, at vores webapplikation til tekstanalyse er blevet verdensberømt. Hver minut modtager den millioner af anmodninger. Det betyder, at mikrotjenesterne sa-webapp og sa-logic vil være under enorm belastning. Hvordan kan vi skalere de containere, som mikrotjenesterne kører i?

Kilde: habr.com