På vår forespørsel opprettet Habr et knutepunkt og vi er glade for å kunne plassere den første publikasjonen i den. Abonnere!
Kubernetes er enkelt. Hvorfor betaler bankene meg mye penger for å jobbe i dette området, mens hvem som helst kan mestre denne teknologien på bare noen få timer?
Hvis du tviler på at Kubernetes kan læres så raskt, foreslår jeg at du prøver det selv. Etter å ha mestret dette materialet, vil du nemlig kunne kjøre en applikasjon basert på mikrotjenester i en Kubernetes-klynge. Jeg kan garantere dette, siden det er nøyaktig samme metodikk som brukes her som jeg lærer kundene våre å jobbe med Kubernetes. Hva skiller denne veiledningen fra andre? Faktisk er det mange ting. Så de fleste av disse materialene begynner med en forklaring av enkle ting - konseptene til Kubernetes og funksjonene til kubectl-kommandoen. Forfatterne av dette materialet antar at leserne deres er kjent med applikasjonsutvikling, mikrotjenester og Docker-beholdere. Vi vil gå den andre veien. Først skal vi snakke om hvordan du kjører en applikasjon basert på mikrotjenester på en datamaskin. Deretter skal vi se på å bygge containerbilder for hver mikrotjeneste. Og etter det vil vi bli kjent med Kubernetes og se på å distribuere en applikasjon basert på mikrotjenester i en klynge administrert av Kubernetes.
Denne tilnærmingen, med en gradvis tilnærming til Kubernetes, vil gi den dybden av forståelsen av hva som skjer som er nødvendig for den gjennomsnittlige personen for å forstå hvor enkelt alt fungerer i Kubernetes. Kubernetes er absolutt en enkel teknologi, forutsatt at de som ønsker å lære den vet hvor og hvordan den brukes.
Nå, uten videre, la oss komme i gang og snakke om applikasjonen vi skal jobbe med.
Eksperimentell applikasjon
Vår applikasjon vil kun utføre én funksjon. Den tar en setning som input, hvoretter den, ved hjelp av tekstanalyseverktøy, utfører sentimentanalyse av denne setningen, og får en vurdering av den følelsesmessige holdningen til forfatteren av setningen til et bestemt objekt.
Slik ser hovedvinduet til denne applikasjonen ut.
Webapplikasjon for sentimentanalyse av tekster
Fra et teknisk synspunkt består applikasjonen av tre mikrotjenester, som hver løser et spesifikt sett med problemer:
- SA-Frontend er en Nginx-webserver som serverer statiske React-filer.
- SA-WebApp er en nettapplikasjon skrevet i Java som behandler forespørsler fra frontend.
- SA-Logic er en Python-applikasjon som utfører sentimentanalyse på tekst.
Det er viktig å merke seg at mikrotjenester ikke eksisterer isolert. De implementerer ideen om "separasjon av ansvar", men samtidig må de samhandle med hverandre.
Dataflyter i applikasjonen
I diagrammet ovenfor kan du se de nummererte stadiene i systemet, som illustrerer datastrømmene i applikasjonen. La oss se på dem:
- Nettleseren ber om en fil fra serveren
index.html(som igjen laster ned React-applikasjonspakken). - Brukeren samhandler med applikasjonen, dette forårsaker et kall til den Spring-baserte nettapplikasjonen.
- Nettapplikasjonen videresender forespørselen om å utføre tekstanalyse til Python-applikasjonen.
- Python-applikasjonen utfører sentimentanalyse av teksten og returnerer resultatet som et svar på forespørselen.
- Spring-applikasjonen sender et svar til React-applikasjonen (som igjen viser resultatet av tekstanalysen til brukeren).
Koden for alle disse applikasjonene kan bli funnet . Jeg anbefaler at du kopierer dette depotet for deg selv akkurat nå, siden det er mange interessante eksperimenter med det foran oss.
Kjøre en mikrotjenestebasert applikasjon på din lokale maskin
For at applikasjonen skal fungere, må vi starte alle tre mikrotjenestene. La oss starte med den søteste av dem alle - front-end-applikasjonen.
▍Sett opp React for lokal utvikling
For å kjøre en React-applikasjon må du installere Node.js-plattformen og NPM på datamaskinen din. Når du har alt dette installert, bruk terminalen til å navigere til prosjektmappen din sa-frontend og kjør følgende kommando:
npm install
Ved å kjøre denne kommandoen i mappen node_modules avhengighetene til React-applikasjonen vil bli lastet, og det finnes registreringer i filen package.json. Når avhengighetene er lastet ned i samme mappe, kjør følgende kommando:
npm start
Det er alt. Nå kjører React-applikasjonen, du kan få tilgang til den ved å gå til følgende adresse i nettleseren din: localhost:3000. Du kan endre noe i koden. Du vil umiddelbart se effekten av disse endringene i nettleseren. Dette er mulig takket være den såkalte "varme" utskiftingen av moduler. Dette gjør frontend-utvikling til en enkel og hyggelig opplevelse.
▍Utarbeidelse av en React-applikasjon for produksjon
For å faktisk bruke en React-applikasjon, må vi konvertere den til et sett med statiske filer og levere dem til klienter som bruker en webserver.
For å bygge React-applikasjonen, igjen ved å bruke terminalen, naviger til mappen sa-frontend og kjør følgende kommando:
npm run build
Dette vil opprette en katalog i prosjektmappen build. Den vil inneholde alle de statiske filene som er nødvendige for at React-applikasjonen skal kjøre.
▍Viser statiske filer ved hjelp av Nginx
Først må du installere og kjøre Nginx-nettserveren. du kan laste den ned og finne instruksjoner om hvordan du installerer og kjører den. Deretter må du kopiere innholdet i mappen sa-frontend/build til mappe [your_nginx_installation_dir]/html.
Med denne tilnærmingen genereres filen under byggeprosessen til React-applikasjonen index.html vil være tilgjengelig kl [your_nginx_installation_dir]/html/index.html. Dette er filen som Nginx-serveren produserer som standard når den får tilgang til den. Serveren er konfigurert til å lytte på porten 80, men den kan tilpasses slik du trenger ved å redigere filen [your_nginx_installation_dir]/conf/nginx.conf.
Åpne nå nettleseren og gå til localhost:80. Du vil se React-applikasjonssiden.
React-applikasjon servert av Nginx-server
Hvis du nå legger inn noe i feltet Type your sentence og trykk på knappen Send - ingenting vil skje. Men hvis du ser på konsollen, kan du se feilmeldinger der. For å forstå hvor nøyaktig disse feilene oppstår, la oss analysere applikasjonskoden.
▍Frontend-applikasjonskodeanalyse
Ta en titt på filkoden App.js, vi kan se det ved å trykke på knappen Send kaller en metode analyzeSentence(). Koden for denne metoden er gitt nedenfor. Vær oppmerksom på at for hver linje som har en kommentar til skjemaet # Номер, er det en forklaring gitt under koden. Vi vil analysere andre kodefragmenter på samme måte.
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-forespørselen sendes til. Det forutsettes at det ligger en søknad på denne adressen som forventer slike forespørsler.
2.Forespørselsorganet sendt til søknaden. Her er et eksempel på forespørselstekst:
{
sentence: "I like yogobella!"
}
3.Når et svar på en forespørsel mottas, oppdateres tilstanden til komponenten. Dette fører til at komponenten blir gjengitt på nytt. Hvis vi mottar data (det vil si et JSON-objekt som inneholder inndataene og den beregnede tekstscore), vil vi sende ut komponenten Polarity, siden de aktuelle vilkårene vil være oppfylt. Slik beskriver vi komponenten:
const polarityComponent = this.state.polarity !== undefined ?
<Polarity sentence={this.state.sentence}
polarity={this.state.polarity}/> :
null;
Koden ser ut til å fungere ganske bra. Hva er galt med dette, forresten? Hvis du antar at på adressen som applikasjonen prøver å sende en POST-forespørsel til, er det ingenting ennå som kan godta og behandle denne forespørselen, så vil du ha helt rett. Nemlig å behandle forespørsler mottatt kl http://localhost:8080/sentiment, må vi kjøre en nettapplikasjon basert på Spring.
Vi trenger en vårsøknad som kan godta en POST-forespørsel
▍ Sette opp en Spring-basert nettapplikasjon
For å distribuere en Spring-applikasjon trenger du JDK8 og Maven og riktig konfigurerte miljøvariabler. Når du har alt dette installert, kan du fortsette å jobbe med prosjektet vårt.
▍ Pakke en applikasjon inn i en jar-fil
Naviger, ved hjelp av en terminal, til mappen sa-webapp og skriv inn følgende kommando:
mvn install
Etter å ha kjørt denne kommandoen i mappen sa-webapp en katalog vil bli opprettet target. Det er her Java-applikasjonen vil bli plassert, pakket i en jar-fil, representert av filen sentiment-analysis-web-0.0.1-SNAPSHOT.jar.
▍Kjøre en Java-applikasjon
Gå til mappen target og kjør programmet med følgende kommando:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jarDet vil oppstå en feil under kjøring av denne kommandoen. For å begynne å fikse det, kan vi analysere unntaksdetaljene i stabelsporingsdataene:
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 oss er det viktigste her omtalen av umuligheten av å klargjøre meningen sa.logic.api.url. La oss analysere koden der feilen oppstår.
▍Java-applikasjonskodeanalyse
Her er kodebiten der feilen oppstå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 S
entimentControllerdet er et feltsaLogicApiUrl. Verdien er spesifisert av eiendommensa.logic.api.url. - Linje
saLogicApiUrlhenger sammen med verdien/analyse/sentiment. Sammen danner de adressen for å ringe mikrotjenesten som utfører tekstanalyse.
▍Angi en egenskapsverdi
Om våren er standardkilden til eiendomsverdier en fil application.properties, som finnes på sa-webapp/src/main/resources. Men bruken er ikke den eneste måten å sette eiendomsverdier på. Dette kan også gjøres ved å bruke følgende kommando:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URLVerdien av denne egenskapen skal peke til adressen til Python-applikasjonen vår.
Ved å konfigurere den forteller vi Spring-webapplikasjonen hvor den må gå for å utføre tekstanalyseforespørsler.
For ikke å komplisere livet vårt, vil vi bestemme at Python-applikasjonen vil være tilgjengelig på localhost:5000 og la oss prøve å ikke glemme det. Som et resultat vil kommandoen for å starte Spring-applikasjonen se slik ut:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000
Systemet vårt mangler en Python-applikasjon
Nå er det bare å kjøre Python-applikasjonen og systemet vil fungere som forventet.
▍ Sette opp en Python-applikasjon
For å kjøre en Python-applikasjon må du ha Python 3 og Pip installert, og de riktige miljøvariablene må settes riktig.
▍Installere avhengigheter
Gå til prosjektmappen din sa-logic/sa og kjør følgende kommandoer:
python -m pip install -r requirements.txt
python -m textblob.download_corpora▍Start applikasjonen
Etter å ha installert avhengighetene, er vi klare til å kjøre applikasjonen:
python sentiment_analysis.pyEtter å ha kjørt denne kommandoen vil vi bli fortalt følgende:
* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
Dette betyr at applikasjonen kjører og venter på forespørsler kl localhost:5000/
▍Kodeforskning
La oss se på Python-applikasjonskoden for å forstå hvordan den svarer på forespørsler:
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- Initialisere et objekt
Flask. - Spesifisere en adresse for å utføre POST-forespørsler til den.
- Hente en eiendom
sentencefra forespørselsorganet. - Initialisere et anonymt objekt
TextBlobog få verdienpolarityfor den første setningen mottatt i selve forespørselen (i vårt tilfelle er dette den eneste setningen som er sendt til analyse). - Returnerer et svar hvis brødtekst inneholder teksten til setningen og den beregnede indikatoren for den
polarity. - Start en Flask-applikasjon, som vil være tilgjengelig på
0.0.0.0:5000(du kan også få tilgang til det ved å bruke en konstruksjon av skjemaetlocalhost:5000).
Mikrotjenestene som utgjør applikasjonen kjører nå. De er innstilt for å samhandle med hverandre. Slik ser applikasjonsdiagrammet ut på dette stadiet av arbeidet.
Alle mikrotjenester som utgjør applikasjonen blir brakt i stand
Nå, før du fortsetter, åpne React-applikasjonen din i en nettleser og prøv å analysere en setning med den. Hvis alt er gjort riktig - etter å ha trykket på knappen Send du vil se analyseresultatene under tekstfeltet.
I neste avsnitt skal vi snakke om hvordan du kjører mikrotjenestene våre i Docker-beholdere. Dette er nødvendig for å forberede applikasjonen til å kjøre på Kubernetes-klyngen.
Docker containere
er et system for automatisering av distribusjon, skalering og administrasjon av containeriserte applikasjoner. Det kalles også en "containerorkestrator". Hvis Kubernetes jobber med containere, må vi først anskaffe disse containerne før vi bruker dette systemet. Men først, la oss snakke om hva containere er. Kanskje det beste svaret på spørsmålet om hva det er, finnes i til Docker:
Et beholderbilde er en lett, selvstendig, kjørbar pakke som inneholder en applikasjon, som inkluderer alt nødvendig for å kjøre den: applikasjonskode, utførelsesmiljø, systemverktøy og biblioteker, innstillinger. Containeriserte programmer kan brukes i Linux- og Windows-miljøer, og de vil alltid fungere likt uavhengig av infrastrukturen.
Dette betyr at containere kan kjøres på hvilken som helst datamaskin, inkludert produksjonsservere, og applikasjonene i dem vil fungere på samme måte i alle miljøer.
For å utforske funksjonene til beholdere og sammenligne dem med andre måter å kjøre applikasjoner på, la oss se på et eksempel på servering av en React-applikasjon ved hjelp av en virtuell maskin og en beholder.
▍Vise statiske filer fra en React-applikasjon ved hjelp av en virtuell maskin
Når vi prøver å organisere tjenesten til statiske filer ved hjelp av virtuelle maskiner, vil vi møte følgende ulemper:
- Ineffektiv bruk av ressurser, siden hver virtuell maskin er et fullverdig operativsystem.
- Plattformavhengighet. Det som fungerer på en lokal datamaskin fungerer kanskje ikke på en produksjonsserver.
- Sakte og ressurskrevende skalering av en virtuell maskinbasert løsning.
Nginx webserver som serverer statiske filer som kjører på en virtuell maskin
Hvis beholdere brukes til å løse et lignende problem, kan følgende styrker bemerkes sammenlignet med virtuelle maskiner:
- Effektiv bruk av ressurser: arbeide med operativsystemet ved hjelp av Docker.
- Plattformuavhengig. En beholder som en utvikler kan kjøre på datamaskinen sin, vil fungere hvor som helst.
- Lett distribusjon gjennom bruk av bildelag.
Nginx webserver som serverer statiske filer som kjører i en beholder
Vi sammenlignet bare virtuelle maskiner og containere på noen få punkter, men selv dette er nok til å få en følelse av styrkene til containere. Du kan finne detaljer om Docker-containere.
▍Bygge et beholderbilde for en React-applikasjon
Den grunnleggende byggesteinen til en Docker-beholder er filen Dockerfile. I begynnelsen av denne filen blir det laget en registrering av basisbildet til beholderen, deretter er det en sekvens med instruksjoner som indikerer hvordan du oppretter en beholder som vil møte behovene til en bestemt applikasjon.
Før vi begynner å jobbe med filen Dockerfile, la oss huske hva vi gjorde for å klargjøre React-applikasjonsfilene for opplasting til Nginx-serveren:
- Bygge en React-applikasjonspakke (
npm run build). - Starter Nginx-serveren.
- Kopiering av kataloginnhold
buildfra prosjektmappesa-frontendtil servermappennginx/html.
Nedenfor kan du se parallellene mellom å lage en beholder og trinnene ovenfor utført på din lokale datamaskin.
▍Forbereder Dockerfilen for SA-Frontend-applikasjonen
Instruksjonene som vil være inneholdt i Dockerfile for søknad SA-Frontend, består av kun to lag. Faktum er at Nginx-utviklingsteamet har utarbeidet en grunnleggende for Nginx, som vi skal bruke til å lage bildet vårt. Dette er de to trinnene vi må beskrive:
- Grunnlaget for bildet bør være Nginx-bildet.
- Mappeinnhold
sa-frontend/buildmå kopieres til bildemappennginx/html.
Hvis du går fra denne beskrivelsen til filen Dockerfile, så vil det se slik ut:
FROM nginx
COPY build /usr/share/nginx/html
Som du kan se, er alt her veldig enkelt, og innholdet i filen viser seg til og med å være ganske lesbart og forståelig. Denne filen forteller systemet å ta bildet nginx med alt som allerede er i den, og kopier innholdet i katalogen build til katalogen nginx/html.
Her har du kanskje et spørsmål om hvordan jeg vet hvor nøyaktig du trenger å kopiere filer fra mappen build, altså hvor stien kom fra /usr/share/nginx/html. Faktisk er det ikke noe komplisert her heller. Faktum er at relevant informasjon kan finnes i bilde.
▍Bygge bildet og laste det opp til depotet
Før vi kan jobbe med det ferdige bildet, må vi skyve det til bildelageret. For å gjøre dette, vil vi bruke den gratis skybildevertsplattformen Docker Hub. På dette stadiet av arbeidet må du gjøre følgende:
- Installere .
- Registrer deg på Docker Hub-nettstedet.
- Logg på kontoen din ved å kjøre følgende kommando i terminalen:
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
Nå må du bruke terminalen for å gå til katalogen sa-frontend og kjør følgende kommando der:
docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .
Her og videre i lignende kommandoer $DOCKER_USER_ID bør erstattes med Docker Hub-brukernavnet ditt. For eksempel kan denne delen av kommandoen se slik ut: rinormaloku/sentiment-analysis-frontend.
I dette tilfellet kan denne kommandoen forkortes ved å fjerne fra den -f Dockerfile, siden denne filen allerede eksisterer i mappen der vi utfører denne kommandoen.
For å sende det ferdige bildet til depotet, trenger vi følgende kommando:
docker push $DOCKER_USER_ID/sentiment-analysis-frontendEtter å ha fullført det, sjekk listen over lagrene dine på Docker Hub for å forstå om opplastingen av bildet til skylagringen var vellykket.
▍Kjøre en container
Nå kan hvem som helst laste ned og kjøre bildet, kjent som $DOCKER_USER_ID/sentiment-analysis-frontend. For å gjøre dette, må du kjøre følgende kommandosekvens:
docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend
Nå beholderen kjører, kan vi fortsette å jobbe ved å lage andre bilder vi trenger. Men før vi fortsetter, la oss forstå designet 80:80, som vises i bildestartskommandoen og kan virke forvirrende.
- Første nummer
80— dette er vertsportnummeret (det vil si den lokale datamaskinen). - Andre nummer
80er havnen i containeren som forespørselen skal sendes til.
Tenk på følgende illustrasjon.
Port Forwarding
Systemet omdirigerer forespørsler fra porten <hostPort> til havnen <containerPort>. Det vil si tilgang til havnen 80 datamaskinen blir omdirigert til porten 80 container.
Siden havnen 80 åpnet på den lokale datamaskinen, så kan du få tilgang til applikasjonen fra denne datamaskinen på localhost:80. Hvis systemet ditt ikke støtter Docker, kan applikasjonen kjøres på en virtuell Docker-maskin, adressen til denne vil se ut som <docker-machine ip>:80. For å finne ut IP-adressen til den virtuelle Docker-maskinen, kan du bruke kommandoen docker-machine ip.
På dette tidspunktet, etter vellykket lansering av front-end-applikasjonsbeholderen, bør du kunne åpne siden i nettleseren.
▍Dockerignore-filen
Samle et applikasjonsbilde SA-Frontend, kunne vi legge merke til at denne prosessen viser seg å være ekstremt sakte. Dette skjer fordi bildebyggekonteksten må sendes til Docker-demonen. Katalogen som representerer byggekonteksten er spesifisert som det siste argumentet for kommandoen docker build. I vårt tilfelle er det en prikk på slutten av denne kommandoen. Dette fører til at følgende struktur inkluderes i byggekonteksten:
sa-frontend:
| .dockerignore
| Dockerfile
| package.json
| README.md
+---build
+---node_modules
+---public
---src
Men av alle mappene som finnes her, trenger vi bare mappen build. Å laste noe annet er bortkastet tid. Du kan få fart på byggingen ved å fortelle Docker hvilke kataloger du skal ignorere. Det er for å gjøre dette vi trenger filen .dockerignore. Du, hvis du er kjent med filen .gitignore, vil strukturen til denne filen sannsynligvis virke kjent. Den viser kataloger som bildebyggesystemet kan ignorere. I vårt tilfelle ser innholdet i denne filen slik ut:
node_modules
src
public
fil .dockerignore må være i samme mappe som filen Dockerfile. Nå vil det ta noen sekunder å bygge bildet.
La oss nå jobbe med bildet for Java-applikasjonen.
▍Bygge et beholderbilde for en Java-applikasjon
Vet du hva, du har allerede lært alt du trenger å vite for å lage containerbilder. Derfor blir denne delen veldig kort.
Åpne filen Dockerfilesom ligger i prosjektmappen sa-webapp. Hvis du leser teksten i denne filen, vil du bare se to nye konstruksjoner i den, og starter med nøkkelordene ENV и EXPOSE:
ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080
Nøkkelord ENV Lar deg deklarere miljøvariabler inne i Docker-beholdere. Spesielt i vårt tilfelle lar den deg spesifisere en URL for å få tilgang til API-en til applikasjonen som utfører tekstanalyse.
Nøkkelord EXPOSE lar deg fortelle Docker å åpne en port. Vi skal bruke denne porten mens vi kjører applikasjonen. Her kan du merke det i Dockerfile for søknad SA-Frontend det er ingen slik kommando. Dette er kun for dokumentasjonsformål, med andre ord er denne konstruksjonen beregnet på den som skal lese Dockerfile.
Å bygge bildet og skyve det til depotet ser nøyaktig det samme ut som i forrige eksempel. Hvis du ennå ikke er veldig sikker på dine evner, kan du finne de tilsvarende kommandoene i filen README.md i mappen sa-webapp.
▍ Bygge et beholderbilde for en Python-applikasjon
Hvis du ser på innholdet i filen Dockerfile i mappen sa-logic, så finner du ikke noe nytt for deg selv der. Kommandoene for å bygge bildet og sende det til depotet bør også allerede være kjent for deg, men som med våre andre applikasjoner, kan de finnes i filen README.md i mappen sa-logic.
▍Test av containeriserte applikasjoner
Kan du stole på noe du ikke har testet? Jeg kan ikke også. La oss teste containerne våre.
- La oss starte applikasjonsbeholderen
sa-logicog konfigurer den til å lytte på porten5050:docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic - La oss starte applikasjonsbeholderen
sa-webappog konfigurer den til å lytte på porten8080. I tillegg må vi konfigurere porten der Python-applikasjonen vil lytte etter forespørsler fra Java-applikasjonen ved å tilordne miljøvariabelen på nyttSA_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 å lære hvordan du finner ut IP-adressen til en Docker-beholder eller virtuell maskin, se filen .
La oss starte applikasjonsbeholderen sa-frontend:
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend
Nå er alt klart for å gå til adressen i nettleseren localhost:80 og prøv applikasjonen.
Vær oppmerksom på at hvis du endret porten for sa-webapp, eller hvis du kjører en virtuell Docker-maskin, må du redigere filen App.js fra en mappe sa-frontendved å endre IP-adressen eller portnummeret i metoden analyzeSentence(), erstatte gjeldende informasjon i stedet for utdaterte data. Etter dette må du sette sammen bildet på nytt og bruke det.
Slik ser søknadsdiagrammet vårt ut nå.
Mikrotjenester kjøres i containere
Sammendrag: hvorfor trenger vi en Kubernetes-klynge?
Vi har nettopp undersøkt filene Dockerfile, snakket om hvordan man bygger bilder og skyver dem til et Docker-depot. I tillegg lærte vi hvordan vi kan fremskynde bildemonteringen ved hjelp av filen .dockerignore. Som et resultat kjører våre mikrotjenester nå i Docker-beholdere. Her har du kanskje et helt berettiget spørsmål om hvorfor vi trenger Kubernetes. Den andre delen av dette materialet vil bli viet til å svare på dette spørsmålet. I mellomtiden kan du vurdere følgende spørsmål:
La oss anta at vår nettapplikasjon for tekstanalyse har blitt populær over hele verden. Millioner av forespørsler kommer til ham hvert minutt. Dette betyr at mikrotjenester sa-webapp и sa-logic vil være under enorm belastning. Hvordan skalere beholdere som kjører mikrotjenester?
Kilde: www.habr.com