Kubernetes-gids, deel 1: toepassingen, microservices en containers

Op ons verzoek heeft Habr een hub gecreëerd Kubernetes en we zijn blij om de eerste publicatie daarin te plaatsen. Abonneer je!

Kubernetes is eenvoudig. Waarom betalen banken mij dan veel geld om in dit veld te werken, terwijl iedereen deze technologie letterlijk in enkele uren kan beheersen?

Als je twijfelt of je Kubernetes zo snel kunt leren — probeer het dan zelf. Als je dit materiaal beheerst, kun je een op microservices gebaseerd applicatie lanceren in een Kubernetes-cluster. Dat kan ik garanderen, want ik leer onze klanten precies op deze manier werken met Kubernetes. Wat maakt deze gids anders dan andere? In feite veel dingen. De meeste van dergelijke materialen beginnen met het uitleggen van eenvoudige dingen — de concepten van Kubernetes en de kenmerken van de kubectl-commandoregel. De auteurs van deze materialen gaan ervan uit dat hun lezer bekend is met applicatieontwikkeling, microservices en Docker-containers. Wij nemen echter een andere aanpak. Eerst vertellen we hoe je een op microservices gebaseerd applicatie op je computer kunt uitvoeren. Daarna bekijken we het bouwen van containerafbeeldingen voor elke microservice. Pas daarna maken we kennis met Kubernetes en behandelen we de implementatie van een op microservices gebaseerd applicatie in een cluster dat door Kubernetes wordt beheerd.

Deze benadering, die geleidelijk naar Kubernetes toewerkt, zal de diepgang van begrip bieden die een gemiddelde persoon nodig heeft om te begrijpen hoe eenvoudig alles is in Kubernetes. Kubernetes is ongetwijfeld een eenvoudige technologie, op voorwaarde dat degene die het wil leren weet waar en hoe het wordt gebruikt.

Laten we nu, zonder verdere woorden, aan de slag gaan en het hebben over de applicatie waarmee we gaan werken.

Experimentele applicatie

Onze applicatie zal slechts één functie uitvoeren. Het accepteert als invoer één zin en gebruikt vervolgens middelen voor tekstanalyse om de sentimentanalyse van deze zin uit te voeren, waardoor een beoordeling van de emotionele houding van de auteur ten opzichte van een bepaald object ontstaat.

Zo ziet het hoofdvenster van deze applicatie eruit.

Webapplicatie voor sentimentanalyse van teksten

Vanuit technisch oogpunt bestaat de applicatie uit drie microservices, waarvan elke een specifieke set taken uitvoert:

• SA-Frontend — een Nginx-webserver die statische React-bestanden bedient.
• SA-WebApp — een webapplicatie geschreven in Java die verzoeken van de frontend verwerkt.
• SA-Logic — een Python-applicatie die de sentimentanalyse van tekst uitvoert.

Het is belangrijk op te merken dat microservices niet in isolatie bestaan. Ze implementeren het idee van "scheiding van verantwoordelijkheden", maar moeten wel met elkaar samenwerken.

Datastromen in de applicatie

In het bovenstaande schema zijn de genummerde fasen van het systeem zichtbaar, die de datastromen in de applicatie illustreren. Laten we ze onder de loep nemen:

1. De browser vraagt het bestand aan de server aan index.html (dat vervolgens het pakket van de React-applicatie laadt).
2. De gebruiker interacteert met de applicatie, dit leidt tot een verzoek aan de webapplicatie, gebaseerd op Spring.
3. De webapplicatie leidt het verzoek door naar de Python-applicatie voor tekstanalyse.
4. De Python-applicatie voert de sentimentanalyse van de tekst uit en retourneert het resultaat als antwoord op het verzoek.
5. De Spring-applicatie stuurt het antwoord terug naar de React-applicatie (deze toont op zijn beurt de resultaat van de tekstanalyse aan de gebruiker).

De code voor al deze applicaties is te vinden hier. Ik raad je aan om dit repository nu direct te kopiëren, aangezien we veel interessante experimenten met het zullen doen.

De applicatie, gebaseerd op microservices, lokaal op de computer uitvoeren

Om de applicatie aan de praat te krijgen, moeten we alle drie microservices opstarten. Laten we beginnen met de mooiste van de drie — de frontend-applicatie.

▍React instellen voor lokale ontwikkeling

Om de React-applicatie te starten, moet je Node.js en NPM op je computer installeren. Nadat je dit hebt geïnstalleerd, ga je met de terminal naar de projectmap sa-frontend en voer de volgende opdracht uit:

npm install

Met deze opdracht worden de afhankelijkheden van de React-applicatie gedownload naar de map node_modules , die in het bestand vermeld staan package.json. Zodra de afhankelijkheden zijn gedownload, voer je in dezelfde map de volgende opdracht uit:

npm start

Dat is alles. Nu is de React-applicatie opgestart en kan deze in de browser worden geopend op het adres localhost:3000. U kunt iets in de code wijzigen. Het effect van deze wijzigingen ziet u onmiddellijk in de browser. Dit is mogelijk dankzij de zogenaamde 'hot' module replacement. Hierdoor wordt frontend-ontwikkeling een eenvoudige en aangename bezigheid.

▍ Voorbereiding van de React-applicatie voor productie

Voor productiegebruik van de React-applicatie moeten we deze omzetten in een set statische bestanden en deze aan klanten aanbieden via een webserver.

Om de React-applicatie te bouwen, gaat u opnieuw naar de map via de terminal sa-frontend en voer de volgende opdracht uit:

npm run build

Dit zal leiden tot het creëren van een map in de projectmap build. Deze bevat alle statische bestanden die nodig zijn voor de werking van de React-applicatie.

▍ Beheer van statische bestanden met Nginx

Eerst moet u de webserver Nginx installeren en starten. Hier kunt u het downloaden en instructies vinden voor de installatie en opstart. Vervolgens moet u de inhoud van de map sa-frontend/build kopiëren naar de map [your_nginx_installation_dir]/html.

Met deze aanpak zal het bestand dat tijdens de bouw van de React-applicatie is gegenereerd index.html beschikbaar zijn op het adres [your_nginx_installation_dir]/html/index.html. Dit is het bestand dat, standaard, door de Nginx-server wordt opgeleverd wanneer het wordt opgeroepen. De server is ingesteld om poort 80te beluisteren, maar kan worden aangepast zoals u dat wilt door het bestand [your_nginx_installation_dir]/conf/nginx.conf.

te bewerken. Open nu uw browser en ga naar het adres localhost:80. U ziet de pagina van de React-applicatie.

React-applicatie die wordt bediend door de Nginx-server

Als u nu iets invoert in het veld Type your sentence en op de knop drukt Verzenden — gebeurt er niets. Maar als u de console bekijkt, kunt u foutmeldingen zien. Om te begrijpen waar deze fouten precies optreden, zullen we de code van de applicatie analyseren.

▍ Analyse van de frontend-applicatiecode

Door naar de code van het bestand App.js, kunnen we zien dat het indrukken van de knop Verzenden de methode analyzeSentence()aanroept. De code van deze methode is hieronder weergegeven. Let op dat elke regel met een commentaar zoals # Номер, een verklaring heeft die onder de code is gegeven. Op dezelfde manier zullen we andere codefragmenten analyseren.

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 waarop de POST-aanroep wordt gedaan. Er wordt aangenomen dat er op dit adres een applicatie is die dergelijke verzoeken verwacht.

2.De body van het verzoek dat naar de applicatie wordt gestuurd. Hier is een voorbeeld van de body van het verzoek:

{
    sentence: "I like yogobella!"
}

3.Bij het ontvangen van een antwoord op het verzoek wordt de status van de component bijgewerkt. Dit leidt tot een her-rendering van de component. Als we gegevens ontvangen (dat wil zeggen — een JSON-object dat de ingevoerde gegevens en de berekende tekstbeoordeling bevat), geven we de component weer Polarity, op voorwaarde dat aan de juiste voorwaarden wordt voldaan. Dit is hoe we de component beschrijven:

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

De code lijkt prima te werken. Wat is er hier nu eigenlijk mis? Als je veronderstelt dat er op het adres waar de applicatie probeert een POST-aanroep te doen, nog niets is om dit verzoek te accepteren en te verwerken, heb je volledig gelijk. Namelijk, om verzoeken die op adres http://localhost:8080/sentiment, te ontvangen, moeten we een op Spring gebaseerde webapplicatie opzetten.

We hebben een Spring-applicatie nodig die POST-verzoeken kan accepteren

▍Opzetten van een op Spring gebaseerde webapplicatie

Om een Spring-applicatie te implementeren, heb je JDK8 en Maven nodig, evenals correct geconfigureerde omgevingsvariabelen. Zodra je dit alles hebt geïnstalleerd, kun je verder werken aan ons project.

▍Toepassing verpakken in een jar-bestand

Navigeer via de terminal naar de map sa-webapp en voer de volgende opdracht in:

mvn install

Na het uitvoeren van deze opdracht wordt in de map sa-webapp een map aangemaakt target. Hier bevindt zich de Java-applicatie verpakt in een jar-bestand, vertegenwoordigd door het bestand sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Java-applicatie starten

Navigeer naar de map target en start de applicatie met de volgende opdracht:

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

Tijdens het uitvoeren van deze opdracht zal er een fout optreden. Om deze te corrigeren, kunnen we de informatie over de uitzondering in de stack trace analyseren:

Fout bij het aanmaken van bean met naam 'sentimentController': Injectie van autowired afhankelijkheden mislukt; geneste uitzondering is java.lang.IllegalArgumentException: Kan plaatsvervanger 'sa.logic.api.url' niet oplossen in waarde "${sa.logic.api.url}"

Voor ons is het belangrijkste hier de vermelding van de onmogelijkheid om de waarde te achterhalen sa.logic.api.url. Laten we de code analyseren waarin de fout optreedt.

▍Analyse van de Java-applicatie

Hier is het codefragment waarin de fout optreedt.

@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. In SentimentController is er een veld saLogicApiUrl. De waarde ervan wordt ingesteld door de eigenschap sa.logic.api.url.
2. String saLogicApiUrl concateneert met de waarde /analyse/sentiment. Samen vormen ze het adres voor het uitvoeren van de aanvraag aan de microservice die de tekstanalyse uitvoert.

▍Instellen van de eigenschapswaarde

In Spring is de standaardbron voor eigenschapswaarden het bestand application.properties, dat kan worden gevonden op het pad sa-webapp/src/main/resources. Maar het gebruik ervan is niet de enige manier om eigenschapswaarden in te stellen. Dit kan ook gedaan worden met behulp van een commando van de volgende vorm:

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

De waarde van deze eigenschap moet verwijzen naar het adres van onze Python-applicatie.

Door het in te stellen, geven we de Spring-webapplicatie aan waarheen deze moet gaan voor tekstanalyse aanvragen.

Om het onszelf niet te moeilijk te maken, zullen we aannemen dat de Python-applicatie bereikbaar is op het adres localhost:5000 en proberen dat niet te vergeten. Als resultaat zal het commando voor het starten van de Spring-applicatie er als volgt uitzien:

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

Onze systeem mist de Python-applicatie

Nu hoeven we alleen nog de Python-applicatie te starten en het systeem zal functioneren zoals verwacht.

▍Configuratie van de Python-applicatie

Om de Python-applicatie te starten, moet Python 3 en Pip zijn geïnstalleerd, en moeten de bijbehorende omgevingsvariabelen correct zijn ingesteld.

▍Installeren van afhankelijkheden

Ga naar de projectmap sa-logic/sa en voer de volgende commando's uit:

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

▍Starten van de applicatie

Na het installeren van de afhankelijkheden zijn we klaar om de applicatie te starten:

python sentiment_analysis.py

Na het uitvoeren van deze opdracht krijgen we het volgende te zien:

* Running on http://0.0.0.0:5000/ (Druk op CTRL+C om te stoppen)

Dit betekent dat de applicatie actief is en wacht op verzoeken op het adres localhost:5000/

▍Code onderzoek

Laten we de Python-applicatie bekijken om te begrijpen hoe deze reageert op verzoeken:

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. Objectinitialisatie Flask.
2. Het instellen van het adres voor het uitvoeren van POST-verzoeken er naartoe.
3. Het extraheren van de eigenschap sentence uit de body van het verzoek.
4. Initialisatie van een anoniem object TextBlob en het verkrijgen van de waarde polarity voor de eerste zin die in de body van het verzoek binnenkomt (in ons geval is dit de enige zin die voor analyse wordt doorgegeven).
5. Het retourneren van een antwoord waarin de tekst van de zin en de berekende score voor deze zin zijn opgenomen. polarity.
6. Het starten van de Flask-applicatie, die beschikbaar zal zijn op het adres 0.0.0.0:5000 (je kunt deze ook benaderen met de structuur van localhost:5000).

Nu zijn de microservices waaruit de applicatie bestaat, geactiveerd. Ze zijn ingesteld om met elkaar te communiceren. Dit is hoe het schema van de applicatie eruitziet in deze fase.

Alle microservices waaruit de applicatie bestaat, zijn operationeel gemaakt.

Nu, voordat we verder gaan, open je de React-applicatie in de browser en probeer een zin te analyseren met behulp daarvan. Als alles goed is gedaan, zie je na het klikken op de knop Verzenden onder het tekstveld de resultaten van de analyse.

In de volgende sectie bespreken we hoe we onze microservices in Docker-containers kunnen draaien. Dit is nodig om de applicatie voor te bereiden voor uitvoering in een Kubernetes-cluster.

Docker-containers

Kubernetes — dit is een systeem voor het automatiseren van de implementatie, schaling en het beheer van container-gebaseerde applicaties. Het wordt ook wel een 'container orchestrator' genoemd. Als Kubernetes met containers werkt, moeten we, voordat we dit systeem gebruiken, eerst deze containers verkrijgen. Maar laten we eerst bespreken wat containers zijn. De beste uitleg over wat dit is, kan gevonden worden in de documentatie van Docker:

Een containerimage is een lichte, autonome, uitvoerbare package die een bepaalde applicatie bevat, inclusief alles wat nodig is om deze uit te voeren: de applicatiecode, de runtime-omgeving, systeemtools en bibliotheken, configuraties. Container-gebaseerde applicaties kunnen worden gebruikt in zowel Linux- als Windows-omgevingen, en ze zullen altijd op dezelfde manier werken, ongeacht de infrastructuur.

Dit betekent dat containers op elke computer kunnen worden uitgevoerd, ook op productie-servers, en in elke omgeving zullen de daarin verpakte applicaties op dezelfde manier functioneren.

Om de eigenschappen van containers te verkennen en deze te vergelijken met andere manieren van het uitvoeren van applicaties, nemen we een voorbeeld van het bedienen van een React-applicatie met behulp van een virtuele machine en een container.

▍Bediening van statische bestanden van een React-applicatie met virtuele machine-technologie

Bij het proberen om statische bestanden te serveren met virtuele machines, zullen we tegen de volgende nadelen aanlopen:

1. Inefficiënt gebruik van middelen, aangezien elke virtuele machine een volledige besturingssystem is.
2. Afhankelijkheid van het platform. Wat op een lokale computer werkt, kan mogelijk niet werken op een productie-server.
3. Langzame en middelen-intensievere schaling van oplossingen die gebaseerd zijn op virtuele machines.

Webserver Nginx, die statische bestanden serveert, draait op een virtuele machine

Als we voor een soortgelijke taak containers gebruiken, kunnen we in vergelijking met virtuele machines de volgende sterke punten opmerken:

1. Efficiënt gebruik van middelen: werken met het besturingssysteem via Docker.
2. Onafhankelijkheid van het platform. Een container die een ontwikkelaar op zijn computer kan draaien, werkt overal.
3. Lichtgewicht implementatie door het gebruik van afbeeldingslagen.

Webserver Nginx, die statische bestanden bedient, draait in een container.

We hebben virtuele machines en containers slechts op enkele punten vergeleken, maar zelfs dat is voldoende om de sterke punten van containers te ervaren. Hier je kunt meer details over Docker-containers vinden.

▍Het bouwen van een containerafbeelding voor een React-applicatie

De belangrijkste bouwsteen van een Docker-container is het bestand Dockerfile. Aan het begin van dit bestand wordt er een opname gemaakt van de basisafbeelding van de container, gevolgd door een reeks instructies die de volgorde aangeven voor het creëren van de container die aan de behoeften van een bepaalde applicatie zal voldoen.

Voordat we aan het werk gaan met het bestand Dockerfile, laten we herinneren wat we hebben gedaan om de bestanden van de React-applicatie voor te bereiden voor implementatie op de Nginx-server:

1. Het bouwen van het pakket voor de React-applicatie (npm run build).
2. Het draaien van de Nginx-server.
3. Het kopiëren van de inhoud van de map build uit de projectmap sa-frontend naar de servermap nginx/html.

Hieronder zie je de parallellen tussen het creëren van een container en de hierboven beschreven acties die op de lokale computer worden uitgevoerd.

▍Voorbereiding van het Dockerfile voor de SA-Frontend-applicatie

De instructies die in Dockerfile voor de applicatie SA-Frontend, bestaan uit slechts twee opdrachten. Het punt is dat de groep ontwikkelaars van Nginx een basis afbeelding voor Nginx heeft voorbereid, die we gaan gebruiken om onze afbeelding te maken. Hier zijn de twee stappen die we moeten beschrijven:

1. De basisafbeelding moet de afbeelding van Nginx zijn.
2. De inhoud van de map sa-frontend/build moet gekopieerd worden naar de afbeeldingsmap. nginx/html.

Als we deze beschrijving naar het bestand omzetten, zou het er als volgt uitzien: DockerfileFROM nginx COPY build /usr/share/nginx/html

Zoals je ziet, is alles hier heel eenvoudig, en de inhoud van het bestand blijkt zelfs vrij leesbaar en begrijpelijk te zijn. Dit bestand vertelt het systeem dat het de afbeelding moet nemen

nginx met alles wat daarin al aanwezig is, en de inhoud van de map naar de map build te kopiëren. nginx/html.

Hier kan de vraag rijzen waar ik weet dat ik de bestanden vanuit de map moet kopiëren build, oftewel — vanwaar de pad komt. /usr/share/nginx/html. Het is eigenlijk helemaal niet moeilijk. Het punt is dat de relevante informatie te vinden is in de beschrijving van het beeld.

▍Het bouwen van het beeld en het uploaden naar de repository

Voordat we met het gemaakte beeld kunnen werken, moeten we het naar de beeldrepository sturen. Hiervoor maken we gebruik van het gratis cloudplatform voor het hosten van beelden, Docker Hub. Op dit punt moet je het volgende doen:

1. Installeer Docker.
2. Registreer je op de website van Docker Hub.
3. Log in op je account door in de terminal het volgende commando uit te voeren:

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

Ga nu met de terminal naar de map sa-frontend en voer daar het volgende commando uit:

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

Hier en verder in soortgelijke commando's $DOCKER_USER_ID moet worden vervangen door je gebruikersnaam op Docker Hub. Bijvoorbeeld, dit deel van het commando kan er als volgt uitzien: rinormaloku/sentiment-analysis-frontend.

Daarnaast kan dit commando worden ingekort door -f Dockerfilete verwijderen, omdat dit bestand al aanwezig is in de map waarin we dit commando uitvoeren.

Om het uiteindelijke beeld naar de repository te sturen, hebben we het volgende commando nodig:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Controleer na uitvoering de lijst van je repositories op Docker Hub om te zien of het uploaden van het beeld naar de cloud succesvol was.

▍De container starten

Nu kan iedereen het beeld downloaden en starten dat bekend staat als $DOCKER_USER_ID/sentiment-analysis-frontend. Hiervoor moet je de volgende reeks commando's uitvoeren:

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

De container is nu gestart en we kunnen verdergaan met het creëren van andere benodigde beelden. Maar voordat we dat doen, laten we de constructie bekijken 80:80, die voorkomt in het commando voor het starten van het beeld en misschien onduidelijk lijkt.

• Het eerste getal 80 is het poortnummer van de host (dat is de lokale computer).
• Het tweede getal 80 is de poort van de container waar het verzoek naartoe moet worden omgeleid.

Laten we de volgende illustratie bekijken.

Poorten omleiden

Het systeem leidt verzoeken van poort <hostPort> naar poort <containerPort>. Dit betekent dat een verzoek naar poort 80 van de computer wordt omgeleid naar poort 80 van de container.

Aangezien poort 80 opend op een lokale computer, dan kun je de toepassing vanaf deze computer benaderen via het adres localhost:80. Als je systeem Docker niet ondersteunt, kun je de toepassing starten op een Docker virtuele machine, waarvan het adres eruit zal zien als :80. Om het IP-adres van de Docker virtuele machine te achterhalen, kun je gebruikmaken van de opdracht docker-machine ip.

Op dit moment, na het succesvol starten van de frontend-toepassingscontainer, zou je in staat moeten zijn om de pagina ervan in de browser te openen.

▍Het .dockerignore-bestand

Bij het bouwen van de applicatie-image SA-Frontend, hebben we opgemerkt dat dit proces extreem langzaam kan zijn. Dit komt doordat de Docker-daemon de context voor het bouwen van de image moet ontvangen. De map die de bouwcontext vertegenwoordigt, wordt opgegeven als het laatste argument van de opdracht docker build. In ons geval staat er een punt aan het einde van deze opdracht. Dit betekent dat de volgende structuur in de bouwcontext wordt opgenomen:

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

Maar van alle hier aanwezige mappen hebben we alleen de map build. Het downloaden van iets anders is een verspilling van tijd. De bouw kan versneld worden door Docker te instrueren welke mappen genegeerd kunnen worden. Daarom hebben we het bestand .dockerignore. Als je bekend bent met het bestand .gitignore, zal de structuur van dit bestand je vast bekend voorkomen. Het bevat een lijst van mappen die het bouwsysteem kan negeren. In ons geval ziet de inhoud van dit bestand er als volgt uit:

node_modules
src
public

Bestand .dockerignore moet zich in dezelfde map bevinden als het bestand Dockerfile. Nu zal het bouwen van de image maar enkele seconden in beslag nemen.

Laten we nu het image voor de Java-toepassing aanpakken.

▍Bouw het containerimage voor de Java-toepassing

Weet je wat, je hebt al alles geleerd wat nodig is om containerimages te maken. Daarom zal dit gedeelte vrij kort zijn.

Open het bestand Dockerfile, dat zich in de projectmap bevindt sa-webapp. Als je de tekst van dit bestand leest, zul je slechts twee nieuwe constructies tegenkomen, die beginnen met de sleutelwoorden ENV en EXPOSE:

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

Sleutelwoord ENV maakt het mogelijk om omgevingsvariabelen binnen Docker-containers te declareren. In ons geval stelt het ons in staat om de URL voor toegang tot de API van de applicatie die de tekst analyseert op te geven.

Sleutelwoord EXPOSE maakt het Docker duidelijk dat de poort geopend moet worden. We gaan deze poort gebruiken tijdens het werken met de applicatie. Hier valt op dat er in Dockerfile voor de applicatie SA-Frontend zo'n commando niet bestaat. Dit is alleen bedoeld voor documentatiedoeleinden, met andere woorden, deze constructie is bedoeld voor degenen die het zullen lezen. Dockerfile.

Het bouwen van een afbeelding en het verzenden ervan naar de repository gebeurt precies zoals in het vorige voorbeeld. Als je nog niet helemaal zeker bent van je vaardigheden, kun je de relevante opdrachten in het bestand vinden. README.md in de map sa-webapp.

▍Het bouwen van de container afbeelding voor een Python-applicatie

Als je naar de inhoud van het bestand kijkt Dockerfile in de map sa-logic, zul je daar niets nieuws voor jezelf vinden. De opdrachten voor het bouwen van de afbeelding en het verzenden naar de repository zouden je ook al bekend moeten zijn, maar deze, net als in het geval van onze andere applicaties, zijn te vinden in het bestand. README.md in de map sa-logic.

▍Het testen van container-applicaties

Kun je iets vertrouwen dat je niet hebt getest? Ik ook niet. Laten we onze containers testen.

1. Laten we de applicatie-container starten sa-logic en deze instellen om poort 5050:

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

2. Laten we de applicatie-container starten sa-webapp en deze instellen om poort 8080. Bovendien moeten we de poort instellen waar de Python-applicatie verzoeken van de Java-applicatie zal afwachten door de omgevingsvariabele SA_LOGIC_API_URL:

   $ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app

Om te leren hoe je het IP-adres van de container of de virtuele Docker-machine kunt achterhalen, raadpleeg het bestand. README.

Laten we de applicatie-container starten sa-frontend:

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

Nu is alles klaar om in de browser naar het adres localhost:80 te gaan en de applicatie te testen.

Let op dat, als je de poort voor sa-webapp, of als je werkt met een virtuele Docker-machine, je het bestand moet bewerken App.js in de map sa-frontend, en het IP-adres of poortnummer in de methode moet wijzigen analyzeSentence(), waarbij je de verouderde gegevens vervangt door actuele informatie. Daarna moet je de afbeelding opnieuw bouwen en deze gebruiken.

Zo ziet onze applicatiestructuur er nu uit.

Microservices draaien in containers

Conclusies: waarom hebben we een Kubernetes-cluster nodig?

We hebben zojuist de bestanden bestudeerd Dockerfile, we talked about how to build images and send them to the Docker repository. Also, we learned how to speed up the image build using a file .dockerignore. As a result, our microservices are now running in Docker containers. You might have a valid question about why we need Kubernetes. The answer to this question will be covered in the second part of this material. For now, consider the following question:
Let's assume that our web application for text analysis has become globally popular. Millions of requests come to it every minute. This means that the microservices sa-webapp en sa-logic will be under tremendous load. How can we scale the containers in which the microservices run?

Bron: habr.com