Kubernetes självstudie del 1: applikationer, mikrotjänster och behållare

På vår begäran skapade Habr ett nav Kubernetes och vi är glada att kunna placera den första publikationen i den. Prenumerera!

Kubernetes är lätt. Varför betalar banker mig mycket pengar för att arbeta inom detta område, medan vem som helst kan behärska den här tekniken på bara några timmar?

Om du tvivlar på att Kubernetes kan läras in så snabbt, föreslår jag att du provar det själv. När du behärskar detta material kommer du nämligen att kunna köra en applikation baserad på mikrotjänster i ett Kubernetes-kluster. Jag kan garantera detta, eftersom det är exakt samma metod som används här som jag lär våra kunder att arbeta med Kubernetes. Vad skiljer den här guiden från andra? Det finns faktiskt många saker. Så de flesta av dessa material börjar med en förklaring av enkla saker - begreppen Kubernetes och funktionerna i kommandot kubectl. Författarna till detta material antar att deras läsare är bekanta med applikationsutveckling, mikrotjänster och Docker-behållare. Vi kommer att gå åt andra hållet. Först ska vi prata om hur man kör en applikation baserad på mikrotjänster på en dator. Sedan ska vi titta på att bygga behållarbilder för varje mikrotjänst. Och efter det kommer vi att bekanta oss med Kubernetes och titta på att distribuera en applikation baserad på mikrotjänster i ett kluster som hanteras av Kubernetes.

Detta tillvägagångssätt, med ett gradvis förhållningssätt till Kubernetes, kommer att ge en djup förståelse för vad som händer som är nödvändig för en genomsnittlig person för att förstå hur enkelt allt fungerar i Kubernetes. Kubernetes är verkligen en enkel teknik, förutsatt att de som vill lära sig den vet var och hur den används.

Nu, utan vidare, låt oss komma igång och prata om applikationen vi kommer att arbeta med.

Experimentell tillämpning

Vår applikation kommer endast att utföra en funktion. Den tar en mening som input, varefter den, med hjälp av textanalysverktyg, utför en sentimentanalys av denna mening, och erhåller en bedömning av den känslomässiga attityden hos meningens författare till ett visst objekt.

Så här ser det här programmets huvudfönster ut.

Webbapplikation för sentimentanalys av texter

Ur teknisk synvinkel består applikationen av tre mikrotjänster, som var och en löser en specifik uppsättning uppgifter:

• SA-Frontend är en Nginx-webbserver som serverar statiska React-filer.
• SA-WebApp är en webbapplikation skriven i Java som behandlar förfrågningar från frontend.
• SA-Logic är en Python-applikation som utför sentimentanalys på text.

Det är viktigt att notera att mikrotjänster inte existerar isolerat. De implementerar idén om "separation av ansvar", men samtidigt måste de interagera med varandra.

Dataflöden i applikationen

I diagrammet ovan kan du se de numrerade stegen i systemet som illustrerar dataflödena i applikationen. Låt oss titta på dem:

1. Webbläsaren begär en fil från servern index.html (som i sin tur laddar ner applikationspaketet React).
2. Användaren interagerar med applikationen, detta orsakar ett anrop till den Spring-baserade webbapplikationen.
3. Webbapplikationen vidarebefordrar begäran om att utföra textanalys till Python-applikationen.
4. Python-applikationen utför sentimentanalys av texten och returnerar resultatet som ett svar på begäran.
5. Spring-applikationen skickar ett svar till React-applikationen (som i sin tur visar resultatet av textanalysen för användaren).

Koden för alla dessa applikationer kan hittas här. Jag rekommenderar att du kopierar det här förrådet för dig själv just nu, eftersom det finns många intressanta experiment med det framför oss.

Köra en mikrotjänstbaserad applikation på din lokala dator

För att applikationen ska fungera måste vi starta alla tre mikrotjänsterna. Låt oss börja med den sötaste av dem alla - front-end-applikationen.

▍Ställ in React för lokal utveckling

För att kunna köra en React-applikation måste du installera Node.js-plattformen och NPM på din dator. När du har installerat allt detta använder du terminalen för att navigera till din projektmapp sa-frontend och kör följande kommando:

npm install

Genom att köra detta kommando i mappen node_modules beroenden för React-applikationen kommer att laddas, vars register finns i filen package.json. När beroenden har laddats ner i samma mapp, kör följande kommando:

npm start

Det är allt. Nu är React-applikationen igång, du kan komma åt den genom att gå till följande adress i din webbläsare: localhost:3000. Du kan ändra något i dess kod. Du kommer omedelbart att se effekten av dessa ändringar i webbläsaren. Detta är möjligt tack vare det så kallade "heta" utbytet av moduler. Detta gör frontend-utveckling till en enkel och njutbar upplevelse.

▍Förbereda en React-applikation för produktion

För att faktiskt kunna använda en React-applikation måste vi konvertera den till en uppsättning statiska filer och skicka dem till klienter som använder en webbserver.

För att bygga React-applikationen, återigen med hjälp av terminalen, navigera till mappen sa-frontend och kör följande kommando:

npm run build

Detta skapar en katalog i projektmappen build. Den kommer att innehålla alla statiska filer som behövs för att React-applikationen ska fungera.

▍Visa statiska filer med Nginx

Först måste du installera och köra Nginx webbserver. Här du kan ladda ner den och hitta instruktioner om hur du installerar och kör den. Sedan måste du kopiera innehållet i mappen sa-frontend/build till en mapp [your_nginx_installation_dir]/html.

Med detta tillvägagångssätt genereras filen under byggprocessen av React-applikationen index.html kommer att finnas tillgänglig kl [your_nginx_installation_dir]/html/index.html. Det här är filen som Nginx-servern som standard producerar när den kommer åt den. Servern är konfigurerad att lyssna på porten 80, men den kan anpassas som du behöver genom att redigera filen [your_nginx_installation_dir]/conf/nginx.conf.

Öppna nu din webbläsare och gå till localhost:80. Du kommer att se React-ansökningssidan.

React-applikationen serveras av Nginx-servern

Om du nu skriver in något i fältet Type your sentence och tryck på knappen Send - inget kommer att hända. Men om du tittar på konsolen kan du se felmeddelanden där. För att förstå var exakt dessa fel uppstår, låt oss analysera applikationskoden.

▍Front-end-applikationskodanalys

Ta en titt på filkoden App.js, vi kan se det genom att trycka på knappen Send kallar en metod analyzeSentence(). Koden för denna metod ges nedan. Observera att för varje rad som har en kommentar till formuläret # Номер, finns det en förklaring nedanför koden. Vi kommer att analysera andra kodfragment på samma sätt.

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. Webbadressen till vilken POST-begäran görs. Det förutsätts att det finns en ansökan på denna adress som förväntar sig sådana förfrågningar.

2.Begäran skickas till ansökan. Här är ett exempel på en begäran:

{
    sentence: "I like yogobella!"
}

3.När ett svar på en begäran tas emot uppdateras komponentens tillstånd. Detta gör att komponenten återrenderas. Om vi ​​tar emot data (det vill säga ett JSON-objekt som innehåller indata och den beräknade textpoängen), kommer vi att mata ut komponenten Polarity, eftersom lämpliga villkor kommer att vara uppfyllda. Så här beskriver vi komponenten:

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

Koden verkar fungera ganska bra. Vad är det för fel på det här? Om du antar att det på adressen som applikationen försöker skicka en POST-förfrågan till, det inte finns något ännu som kan acceptera och behandla denna begäran, så har du helt rätt. Nämligen att behandla förfrågningar inkomna kl http://localhost:8080/sentiment, måste vi köra en webbapplikation baserad på Spring.

Vi behöver en våransökan som kan acceptera en POST-förfrågan

▍Sätta upp en Spring-baserad webbapplikation

För att kunna distribuera en Spring-applikation behöver du JDK8 och Maven och korrekt konfigurerade miljövariabler. När du har installerat allt detta kan du fortsätta arbeta med vårt projekt.

▍ Packa ett program i en jar-fil

Navigera, med hjälp av en terminal, till mappen sa-webapp och skriv in följande kommando:

mvn install

Efter att ha kört detta kommando i mappen sa-webapp en katalog kommer att skapas target. Det är här Java-applikationen kommer att finnas, förpackad i en jar-fil, representerad av filen sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Köra en Java-applikation

Gå till mappen target och kör programmet med följande kommando:

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

Ett fel kommer att uppstå när detta kommando körs. För att börja fixa det kan vi analysera undantagsdetaljerna i stackspårningsdata:

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

För oss är det viktigaste här omnämnandet av omöjligheten att klargöra innebörden sa.logic.api.url. Låt oss analysera koden där felet uppstår.

▍ Analys av Java-applikationskod

Här är kodavsnittet där felet uppstå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 det finns ett fält saLogicApiUrl. Dess värde anges av fastigheten sa.logic.api.url.
2. Linje saLogicApiUrl sammanlänkas med värdet /analyse/sentiment. Tillsammans bildar de adressen för att ringa till mikrotjänsten som utför textanalys.

▍Ställ in ett egenskapsvärde

På våren är standardkällan för fastighetsvärden en fil application.properties, som finns på sa-webapp/src/main/resources. Men dess användning är inte det enda sättet att sätta fastighetsvärden. Detta kan också göras med följande kommando:

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

Värdet på den här egenskapen bör peka på adressen till vår Python-applikation.

Genom att konfigurera den berättar vi för Spring-webbapplikationen vart den måste gå för att utföra textanalysförfrågningar.

För att inte komplicera vårt liv kommer vi att bestämma att Python-applikationen kommer att finnas tillgänglig på localhost:5000 och låt oss försöka att inte glömma det. Som ett resultat kommer kommandot för att starta Spring-applikationen se ut så här:

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

Vårt system saknar en Python-applikation

Nu är det bara att köra Python-applikationen så kommer systemet att fungera som förväntat.

▍Konfigurera en Python-applikation

För att köra en Python-applikation måste du ha Python 3 och Pip installerade, och lämpliga miljövariabler måste ställas in korrekt.

▍Installera beroenden

Gå till din projektmapp sa-logic/sa och kör följande kommandon:

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

▍Starta programmet

Efter att ha installerat beroenden är vi redo att köra applikationen:

python sentiment_analysis.py

Efter att ha kört detta kommando kommer vi att få veta följande:

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

Det betyder att applikationen är igång och väntar på förfrågningar kl localhost:5000/

▍Kodforskning

Låt oss titta på Python-applikationskoden för att förstå hur den svarar på förfrågningar:

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. Initiera ett objekt Flask.
2. Ange en adress för att utföra POST-förfrågningar till den.
3. Hämta en fastighet sentence från begärandeinstansen.
4. Initiera ett anonymt objekt TextBlob och få värdet polarity för den första meningen som mottogs i huvuddelen av begäran (i vårt fall är detta den enda meningen som skickas för analys).
5. Returnerar ett svar vars brödtext innehåller meningens text och den beräknade indikatorn för den polarity.
6. Starta en Flask-applikation som kommer att finnas tillgänglig på 0.0.0.0:5000 (du kan också komma åt det med hjälp av en konstruktion av formuläret localhost:5000).

Mikrotjänsterna som utgör applikationen körs nu. De är inställda för att interagera med varandra. Så här ser applikationsdiagrammet ut i detta skede av arbetet.

Alla mikrotjänster som utgör applikationen bringas i fungerande skick

Nu, innan du fortsätter, öppna din React-applikation i en webbläsare och försök analysera någon mening med den. Om allt är gjort korrekt - efter att ha tryckt på knappen Send du ser analysresultaten under textfältet.

I nästa avsnitt kommer vi att prata om hur man kör våra mikrotjänster i Docker-behållare. Detta är nödvändigt för att förbereda programmet för att köras på ett Kubernetes-kluster.

Hamnarcontainrar

Kubernetes är ett system för att automatisera driftsättning, skalning och hantering av containeriserade applikationer. Det kallas också en "containerorkestrator". Om Kubernetes arbetar med behållare måste vi först skaffa dessa behållare innan vi använder det här systemet. Men först, låt oss prata om vad behållare är. Det kanske bästa svaret på frågan om vad det är finns i dokumentation till Docker:

En containeravbildning är ett lätt, självständigt, körbart paket som innehåller ett program som inkluderar allt som behövs för att köra det: programkod, körmiljö, systemverktyg och bibliotek samt inställningar. Containeriserade program kan användas i miljöer Linux и Windows, och de kommer alltid att fungera på samma sätt oavsett infrastruktur.

Detta innebär att behållare kan köras på vilken dator som helst, inklusive produktionsservrar, och applikationerna i dem kommer att fungera likadant i alla miljöer.

För att utforska funktionerna hos behållare och jämföra dem med andra sätt att köra applikationer, låt oss titta på ett exempel på hur man servar en React-applikation med en virtuell maskin och en behållare.

▍Visa statiska filer från en React-applikation med hjälp av en virtuell maskin

När vi försöker organisera tjänsten för statiska filer med hjälp av virtuella maskiner kommer vi att stöta på följande nackdelar:

1. Ineffektiv användning av resurser, eftersom varje virtuell maskin är ett fullfjädrat operativsystem.
2. Plattformsberoende. Det som fungerar på en lokal dator kanske inte fungerar på en produktionsserver.
3. Långsam och resurskrävande skalning av en virtuell maskinbaserad lösning.

Nginx webbserver som serverar statiska filer som körs på en virtuell maskin

Om behållare används för att lösa ett liknande problem, i jämförelse med virtuella maskiner, kan följande styrkor noteras:

1. Effektiv användning av resurser: arbeta med operativsystemet med Docker.
2. Plattformsoberoende. En behållare som en utvecklare kan köra på sin dator kommer att fungera var som helst.
3. Lätt implementering genom användning av bildlager.

Nginx webbserver som serverar statiska filer som körs i en behållare

Vi jämförde bara virtuella maskiner och containrar på ett fåtal punkter, men även detta räcker för att få en känsla för styrkorna hos containrar. Här Du kan hitta information om Docker-containrar.

▍Bygga en containerbild för en React-applikation

Den grundläggande byggstenen i en Docker-behållare är filen Dockerfile. I början av den här filen görs en registrering av basbilden av behållaren, sedan finns det en sekvens av instruktioner som anger hur man skapar en behållare som kommer att möta behoven för en viss applikation.

Innan vi börjar arbeta med filen Dockerfile, låt oss komma ihåg vad vi gjorde för att förbereda React-applikationsfilerna för uppladdning till Nginx-servern:

1. Bygga ett React-applikationspaket (npm run build).
2. Startar Nginx-servern.
3. Kopiera kataloginnehåll build från projektmappen sa-frontend till servermappen nginx/html.

Nedan kan du se parallellerna mellan att skapa en container och ovanstående steg som utförs på din lokala dator.

▍Förbereder Dockerfilen för SA-Frontend-applikationen

Instruktionerna som kommer att finnas i Dockerfile för ansökan SA-Frontend, består av endast två lag. Faktum är att Nginx utvecklingsteam har förberett en grundläggande bild för Nginx, som vi kommer att använda för att skapa vår bild. Det här är de två stegen vi behöver beskriva:

1. Grunden för bilden bör vara Nginx-bilden.
2. Mappinnehåll sa-frontend/build måste kopieras till bildmappen nginx/html.

Om du går från den här beskrivningen till filen Dockerfile, då ser det ut så här:

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

Som du kan se är allt här väldigt enkelt, och innehållet i filen visar sig till och med vara ganska läsbart och begripligt. Den här filen talar om för systemet att ta bilden nginx med allt som redan finns i den och kopiera innehållet i katalogen build till katalogen nginx/html.

Här kan du ha en fråga angående hur jag vet exakt var du behöver kopiera filer från mappen build, alltså varifrån stigen kom /usr/share/nginx/html. Det är faktiskt inget komplicerat här heller. Faktum är att relevant information kan hittas i beskrivning bild.

▍ Bygger bilden och laddar upp den till arkivet

Innan vi kan arbeta med den färdiga bilden måste vi skjuta den till bildförrådet. För att göra detta kommer vi att använda den kostnadsfria molnbildsvärdplattformen Docker Hub. I detta skede av arbetet måste du göra följande:

1. upprätta Hamnarbetare.
2. Registrera dig på Docker Hub-webbplatsen.
3. Logga in på ditt konto genom att köra följande kommando i terminalen:

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

Nu måste du använda terminalen för att gå till katalogen sa-frontend och kör följande kommando där:

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

Här och vidare i liknande kommandon $DOCKER_USER_ID bör ersättas med ditt Docker Hub-användarnamn. Till exempel kan den här delen av kommandot se ut så här: rinormaloku/sentiment-analysis-frontend.

I det här fallet kan detta kommando förkortas genom att ta bort det -f Dockerfile, eftersom den här filen redan finns i mappen där vi kör det här kommandot.

För att skicka den färdiga bilden till förvaret behöver vi följande kommando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

När du har slutfört den, kontrollera listan över dina arkiv på Docker Hub för att förstå om uppladdningen av bilden till molnlagringen lyckades.

▍Köra en container

Nu kan vem som helst ladda ner och köra bilden, känd som $DOCKER_USER_ID/sentiment-analysis-frontend. För att göra detta måste du köra följande kommandosekvens:

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

Nu är behållaren igång, vi kan fortsätta arbeta genom att skapa andra bilder vi behöver. Men innan vi fortsätter, låt oss förstå designen 80:80, som visas i bildstartskommandot och kan verka förvirrande.

• Första numret 80 — detta är värdportnumret (det vill säga den lokala datorn).
• Andra nummer 80 är den hamn i containern som begäran ska skickas till.

Betrakta följande illustration.

Port Forwarding

Systemet omdirigerar förfrågningar från porten <hostPort> per port <containerPort>. Det vill säga tillgång till hamnen 80 datorn omdirigeras till porten 80 behållare.

Sedan hamnen 80 öppnas på den lokala datorn, då kan du komma åt programmet från den här datorn på localhost:80. Om ditt system inte stöder Docker kan applikationen köras på en virtuell Docker-maskin, vars adress kommer att se ut <docker-machine ip>:80. För att ta reda på IP-adressen för den virtuella Docker-maskinen kan du använda kommandot docker-machine ip.

Vid det här laget, efter att ha framgångsrikt startat front-end-applikationsbehållaren, bör du kunna öppna dess sida i webbläsaren.

▍ .dockerignore-filen

Samlar en applikationsbild SA-Frontend, kunde vi märka att denna process visar sig vara extremt långsam. Detta händer eftersom bildbyggandekontexten måste skickas till Docker-demonen. Katalogen som representerar byggkontexten anges som det sista argumentet för kommandot docker build. I vårt fall finns det en prick i slutet av detta kommando. Detta gör att följande struktur inkluderas i byggkontexten:

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

Men av alla mappar som finns här behöver vi bara mappen build. Att ladda något annat är slöseri med tid. Du kan påskynda bygget genom att tala om för Docker vilka kataloger du ska ignorera. Det är för att kunna göra detta som vi behöver filen .dockerignore. Du, om du är bekant med filen .gitignore, strukturen för den här filen kommer förmodligen att verka bekant. Den listar kataloger som bildbyggesystemet kan ignorera. I vårt fall ser innehållet i den här filen ut så här:

node_modules
src
public

fil .dockerignore måste finnas i samma mapp som filen Dockerfile. Nu tar det bara några sekunder att bygga bilden.

Låt oss nu arbeta med bilden för Java-applikationen.

▍Bygga en containerbild för en Java-applikation

Vet du vad, du har redan lärt dig allt du behöver veta för att skapa behållarbilder. Det är därför det här avsnittet blir väldigt kort.

Öppna filen Dockerfilesom finns i projektmappen sa-webapp. Om du läser texten i den här filen kommer du bara att se två nya konstruktioner i den, som börjar med nyckelorden ENV и EXPOSE:

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

Nyckelord ENV Låter dig deklarera miljövariabler inuti Docker-behållare. I synnerhet, i vårt fall, låter det dig ange en URL för att komma åt API:et för applikationen som utför textanalys.

Nyckelord EXPOSE låter dig säga åt Docker att öppna en port. Vi kommer att använda den här porten när vi kör programmet. Här kan du märka det i Dockerfile för ansökan SA-Frontend det finns inget sådant kommando. Detta är endast i dokumentationssyfte, med andra ord, denna konstruktion är avsedd för den som ska läsa Dockerfile.

Att bygga bilden och skjuta den till arkivet ser exakt likadant ut som i föregående exempel. Om du ännu inte är så säker på dina förmågor, kan motsvarande kommandon hittas i filen README.md i mappen sa-webapp.

▍Bygga en containerbild för en Python-applikation

Om du tittar på innehållet i filen Dockerfile i mappen sa-logic, då hittar du inget nytt för dig själv där. Kommandon för att bygga bilden och skicka den till förvaret borde också redan vara bekanta för dig, men, precis som med våra andra applikationer, kan de hittas i filen README.md i mappen sa-logic.

▍Testa containeriserade applikationer

Kan du lita på något du inte har testat? Jag kan inte också. Låt oss testa våra containrar.

1. Låt oss starta applikationsbehållaren sa-logic och konfigurera den för att lyssna på porten 5050:

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

2. Låt oss starta applikationsbehållaren sa-webapp och konfigurera den för att lyssna på porten 8080. Dessutom måste vi konfigurera porten på vilken Python-applikationen ska lyssna efter förfrågningar från Java-applikationen genom att omtilldela miljövariabeln 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

För att lära dig hur du tar reda på IP-adressen för en Docker-behållare eller virtuell maskin, se filen README.

Låt oss starta applikationsbehållaren sa-frontend:

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

Nu är allt klart för att gå till adressen i webbläsaren localhost:80 och prova applikationen.

Observera att om du ändrade porten för sa-webapp, eller om du kör en virtuell Docker-maskin måste du redigera filen App.js från mappen sa-frontendgenom att ändra IP-adressen eller portnumret i metoden analyzeSentence(), ersätter aktuell information istället för föråldrad data. Efter detta måste du återmontera bilden och använda den.

Så här ser vårt applikationsdiagram ut nu.

Mikrotjänster körs i containrar

Sammanfattning: varför behöver vi ett Kubernetes-kluster?

Vi har precis granskat akterna Dockerfile, pratade om hur man bygger bilder och skickar dem till ett Docker-förråd. Dessutom lärde vi oss hur man snabbar upp bildsammansättningen med hjälp av filen .dockerignore. Som ett resultat körs våra mikrotjänster nu i Docker-containrar. Här kan du ha en helt berättigad fråga om varför vi behöver Kubernetes. Den andra delen av detta material kommer att ägnas åt att besvara denna fråga. Under tiden, fundera på följande fråga:
Låt oss anta att vår webbapplikation för textanalys har blivit globalt populär. Miljontals förfrågningar kommer till honom varje minut. Detta innebär att mikrotjänster sa-webapp и sa-logic kommer att vara under enorm belastning. Hur skalar man behållare som kör mikrotjänster?

Källa: will.com