Op ons verzoek heeft Habr een hub gemaakt en we zijn verheugd om de eerste publicatie erin te plaatsen. Abonneren!
Kubernetes is eenvoudig. Waarom betalen banken me veel geld om op dit gebied te werken, terwijl iedereen deze technologie in slechts een paar uur onder de knie kan krijgen?
Als je twijfelt of Kubernetes zo snel kan worden geleerd, raad ik je aan het zelf te proberen. Nadat u dit materiaal onder de knie heeft, kunt u namelijk een applicatie uitvoeren op basis van microservices in een Kubernetes-cluster. Dat kan ik garanderen, want het is in dezelfde methodiek die ik hier gebruik dat ik onze klanten leer werken met Kubernetes. Wat maakt deze gids anders dan andere? Eigenlijk een heleboel dingen. De meeste van deze materialen beginnen dus met een uitleg van eenvoudige dingen: de concepten van Kubernetes en de functies van het kubectl-commando. De auteurs van deze artikelen gaan ervan uit dat hun lezer bekend is met applicatie-ontwikkeling, microservices en Docker-containers. We gaan de andere kant op. Laten we het eerst hebben over het uitvoeren van een applicatie op basis van microservices op een computer. Vervolgens kijken we naar het bouwen van container-images voor elke microservice. En daarna maken we kennis met Kubernetes en analyseren we de inzet van een applicatie op basis van microservices in een door Kubernetes beheerd cluster.
Deze benadering, met een geleidelijke benadering van Kubernetes, zal het diepgaande begrip geven van wat er gebeurt dat de gemiddelde persoon nodig heeft om te begrijpen hoe eenvoudig alles in Kubernetes is geregeld. Kubernetes is zeker een simpele technologie, mits wie het onder de knie wil krijgen, weet waar en hoe het gebruikt wordt.
Laten we nu, zonder verder oponthoud, aan het werk gaan en praten over de toepassing waarmee we zullen werken.
Experimentele app
Onze applicatie zal slechts één functie uitvoeren. Het neemt als invoer één zin, waarna het, met behulp van tekstanalysetools, een sentimentanalyse van deze zin uitvoert, waarbij een beoordeling wordt verkregen van de emotionele houding van de auteur van de zin ten opzichte van een bepaald object.
Zo ziet het hoofdvenster van deze applicatie eruit.
Webapplicatie voor sentimentanalyse
Vanuit technisch oogpunt bestaat de applicatie uit drie microservices, die elk een bepaald aantal taken oplossen:
- SA-Frontend is een Nginx-webserver die statische React-bestanden bedient.
- SA-WebApp is een in Java geschreven webapplicatie die verzoeken van de frontend afhandelt.
- SA-Logic is een Python-toepassing die tekstsentimentanalyse uitvoert.
Het is belangrijk op te merken dat microservices niet op zichzelf staan. Ze implementeren het idee van "scheiding van taken", maar ze moeten tegelijkertijd met elkaar omgaan.
Gegevensstromen in de applicatie
In het bovenstaande diagram ziet u de genummerde fasen van het systeem, die de gegevensstromen in de toepassing illustreren. Laten we ze opsplitsen:
- De browser vraagt een bestand op bij de server
index.html(die op zijn beurt het React-app-pakket laadt). - De gebruiker communiceert met de applicatie, dit veroorzaakt een aanroep naar een webapplicatie op basis van Spring.
- De webapplicatie stuurt het verzoek om de tekst te parseren door naar de Python-applicatie.
- De Python-toepassing analyseert het sentiment van de tekst en retourneert het resultaat als antwoord op het verzoek.
- De Spring-applicatie stuurt een reactie naar de React-applicatie (die op zijn beurt het resultaat van de geparseerde tekst aan de gebruiker laat zien).
De code voor al deze toepassingen is te vinden . Ik raad je aan deze repository nu naar jezelf te kopiëren, aangezien er veel interessante experimenten mee voor de boeg zijn.
Een toepassing uitvoeren op basis van microservices op de lokale computer
Om de applicatie te laten werken, moeten we alle drie de microservices starten. Laten we beginnen met de mooiste: de front-end applicatie.
▍Opzetten van React voor lokale ontwikkeling
Om een React-toepassing uit te voeren, moet u het Node.js-framework en NPM op uw computer installeren. Nadat je dit alles hebt geïnstalleerd, ga je via de terminal naar de projectmap sa-frontend en voer het volgende commando uit:
npm install
Door deze opdracht uit te voeren in de map node_modules de afhankelijkheden van de React-applicatie worden geladen, waarvan de records in het bestand staan package.json. Voer na het downloaden van de afhankelijkheden in dezelfde map de volgende opdracht uit:
npm start
Dat is alles. De React-app is nu actief en is toegankelijk door naar het browseradres te navigeren localhost:3000. Je kunt iets in zijn code veranderen. U ziet direct het effect van deze wijzigingen in de browser. Dit is mogelijk dankzij de zogenaamde "hot" vervanging van modules. Hierdoor wordt front-end ontwikkeling een eenvoudige en plezierige ervaring.
▍Een React-app voorbereiden voor productie
Om een React-app daadwerkelijk te kunnen gebruiken, moeten we deze converteren naar een set statische bestanden en deze aan klanten aanbieden via een webserver.
Om de React-app te bouwen, navigeert u opnieuw met behulp van de terminal naar de map sa-frontend en voer het volgende commando uit:
npm run build
Hiermee wordt een map in de projectmap gemaakt build. Het bevat alle statische bestanden die nodig zijn om de React-applicatie te laten werken.
▍Statische bestanden aanbieden met Nginx
Eerst moet u de Nginx-webserver installeren en uitvoeren. u kunt het downloaden en instructies vinden voor het installeren en uitvoeren ervan. Vervolgens moet u de inhoud van de map kopiëren sa-frontend/build naar map [your_nginx_installation_dir]/html.
Met deze aanpak wordt het bestand gegenereerd tijdens de montage van de React-applicatie index.html zal beschikbaar zijn op [your_nginx_installation_dir]/html/index.html. Dit is het bestand dat de Nginx-server standaard uitgeeft bij toegang. De server is geconfigureerd om op een poort te luisteren 80, maar u kunt het naar wens aanpassen door het bestand te bewerken [your_nginx_installation_dir]/conf/nginx.conf.
Open nu uw browser en ga naar localhost:80. U ziet de React-app-pagina.
Reageer app bediend door Nginx-server
Als je nu iets invult in het veld Type your sentence en druk op de knop Send - er zal niks gebeuren. Maar als u naar de console kijkt, ziet u daar foutmeldingen. Laten we de toepassingscode analyseren om precies te begrijpen waar deze fouten optreden.
▍Analyse van de code van de front-end applicatie
Kijkend naar de code van het bestand App.js, kunnen we zien dat klikken op de knop Send noemt een methode analyzeSentence(). De code voor deze methode wordt hieronder weergegeven. Let er tegelijkertijd op dat er voor elke regel een opmerking op het formulier staat # Номер, staat er een uitleg onder de code. Op dezelfde manier zullen we andere codefragmenten ontleden.
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. De URL waarnaar het POST-verzoek wordt verzonden. Dit adres wordt verondersteld een toepassing te zijn die wacht op dergelijke verzoeken.
2.De aanvraaginstantie die naar de toepassing is verzonden. Hier is een voorbeeld van een aanvraagtekst:
{
sentence: "I like yogobella!"
}
3.Wanneer een antwoord op een verzoek wordt ontvangen, wordt de status van de component bijgewerkt. Hierdoor wordt de component opnieuw weergegeven. Als we gegevens ontvangen (dat wil zeggen een JSON-object met de ingevoerde gegevens en de berekende tekstscore), zullen we de component uitvoeren Polarityzolang aan de voorwaarden wordt voldaan. Hier is hoe we het onderdeel beschrijven:
const polarityComponent = this.state.polarity !== undefined ?
<Polarity sentence={this.state.sentence}
polarity={this.state.polarity}/> :
null;
De code lijkt redelijk goed te werken. Wat is hier eigenlijk mis? Als je ervan uitgaat dat op het adres waarnaar de applicatie een POST-verzoek probeert te sturen, nog niets is dat dit verzoek kan accepteren en verwerken, dan heb je helemaal gelijk. Namelijk om verzoeken te verwerken die naar het adres komen http://localhost:8080/sentiment, moeten we een webapplicatie draaien op basis van Spring.
We hebben een Spring-applicatie nodig die een POST-verzoek kan accepteren
▍Het opzetten van een webapplicatie op basis van Spring
Om een Spring-applicatie te implementeren, hebt u JDK8 en Maven en correct geconfigureerde omgevingsvariabelen nodig. Nadat je dit alles hebt geïnstalleerd, kun je verder werken aan ons project.
▍De applicatie verpakken in een jar-bestand
Navigeer met behulp van de terminal naar de map sa-webapp en voer het volgende commando in:
mvn install
Na het uitvoeren van deze opdracht in de map sa-webapp map wordt aangemaakt target. Hier zal de Java-toepassing zich bevinden, verpakt in een jar-bestand, vertegenwoordigd door het bestand sentiment-analysis-web-0.0.1-SNAPSHOT.jar.
▍Een Java-toepassing starten
Ga naar map target en voer de toepassing uit met de volgende opdracht:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jarEr treedt een fout op bij het uitvoeren van deze opdracht. Om het te repareren, kunnen we de uitzonderingsdetails in de stacktraceergegevens ontleden:
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}"
Voor ons is het belangrijkste hier de vermelding van de onmogelijkheid om de betekenis te verduidelijken sa.logic.api.url. Laten we de code analyseren waar de fout optreedt.
▍Analyse van Java-toepassingscode
Hier is het codefragment waar 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();
}
}- in S
entimentControllerer is een veldsaLogicApiUrl. De waarde wordt bepaald door de eigenschapsa.logic.api.url. - rij
saLogicApiUrlaaneengeschakeld met waarde/analyse/sentiment. Samen vormen ze een adres voor het aanroepen van de microservice die tekstanalyse uitvoert.
▍Een eigenschapswaarde instellen
In Spring is de standaardbron van eigenschapswaarden een bestand application.properties, die te vinden is op sa-webapp/src/main/resources. Maar het gebruik ervan is niet de enige manier om eigenschapswaarden in te stellen. U kunt dit ook doen met de volgende opdracht:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URLDe waarde van deze eigenschap moet verwijzen naar het adres van onze Python-toepassing.
Door het te configureren, vertellen we de Spring-webapplicatie waar deze heen moet om verzoeken voor het parseren van tekst uit te voeren.
Om ons leven niet ingewikkelder te maken, zullen we besluiten dat de Python-applicatie beschikbaar zal zijn op localhost:5000 en probeer het niet te vergeten. Als gevolg hiervan ziet het commando om de Spring-applicatie te starten er als volgt uit:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000
Ons systeem mist een Python-applicatie
Nu hoeven we alleen nog maar de Python-applicatie uit te voeren en het systeem zal werken zoals verwacht.
▍Een Python-toepassing opzetten
Om een Python-toepassing uit te voeren, moet Python 3 en Pip zijn geïnstalleerd en moeten de juiste omgevingsvariabelen correct zijn ingesteld.
▍Installeer afhankelijkheden
Ga naar de projectmap sa-logic/sa en voer de volgende opdrachten uit:
python -m pip install -r requirements.txt
python -m textblob.download_corpora▍App starten
Nu de afhankelijkheden zijn geïnstalleerd, zijn we klaar om de applicatie uit te voeren:
python sentiment_analysis.pyNa het uitvoeren van deze opdracht krijgen we het volgende te horen:
* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
Dit betekent dat de applicatie actief is en wacht op verzoeken om localhost:5000/
▍Code-onderzoek
Laten we eens kijken naar de Python-toepassingscode 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- Object initialisatie
Flask. - Het adres specificeren voor het maken van POST-verzoeken.
- Een eigenschap ophalen
sentencevan de verzoekende instantie. - Anonieme objectinitialisatie
TextBloben de waarde krijgenpolarityvoor het eerste voorstel dat in de hoofdtekst van het verzoek is ontvangen (in ons geval is dit het enige voorstel dat ter analyse is ingediend). - Een reactie retourneren, waarvan de hoofdtekst de tekst van de aanbieding en de daarvoor berekende indicator bevat
polarity. - Lancering van de Flask-applicatie, die beschikbaar zal zijn op
0.0.0.0:5000(u kunt er ook toegang toe krijgen via een constructie van het formulierlocalhost:5000).
Nu zijn de microservices waaruit de applicatie bestaat actief. Ze zijn ingesteld om met elkaar te communiceren. Zo ziet het toepassingsdiagram eruit in deze werkfase.
Alle microservices waaruit de applicatie bestaat, worden in een gezonde staat gebracht
Voordat we verder gaan, open je de React-app in een browser en probeer je er een zin mee te ontleden. Als alles correct is gedaan - na het indrukken van de knop Send u ziet de analyseresultaten onder het tekstvak.
In het volgende gedeelte zullen we het hebben over het uitvoeren van onze microservices in Docker-containers. Dit is nodig om de applicatie voor te bereiden op uitvoering in het Kubernetes-cluster.
Docker-containers
is een systeem voor het automatiseren van de implementatie, schaalvergroting en het beheer van gecontaineriseerde applicaties. Het wordt ook wel een "containerorkestrator" genoemd. Als Kubernetes met containers werkt, moeten we voordat we dit systeem gaan gebruiken eerst deze containers aanschaffen. Maar laten we eerst eens kijken wat containers zijn. Misschien is het beste antwoord op de vraag wat het is te vinden in naar Docker:
Een containerimage is een lichtgewicht, op zichzelf staand, uitvoerbaar pakket dat een applicatie bevat, die alles bevat wat nodig is om het uit te voeren: applicatiecode, runtime-omgeving, systeemtools en bibliotheken, instellingen. Gecontaineriseerde programma's kunnen zowel in Linux- als Windows-omgevingen worden gebruikt en werken altijd hetzelfde, ongeacht de infrastructuur.
Dit betekent dat containers op elke computer kunnen worden uitgevoerd, inclusief productieservers, en in elke omgeving zullen de applicaties die erin zijn ingesloten op dezelfde manier werken.
Om de kenmerken van containers te verkennen en ze te vergelijken met andere manieren om applicaties uit te voeren, laten we eens kijken naar het voorbeeld van het bedienen van een React-applicatie met behulp van een virtuele machine en een container.
▍Statische bestanden van een React-toepassing aanbieden met behulp van een virtuele machine
Als we het onderhoud van statische bestanden proberen te organiseren met behulp van virtuele machines, zullen we de volgende nadelen tegenkomen:
- Inefficiënt gebruik van bronnen, aangezien elke virtuele machine een compleet besturingssysteem is.
- Platform afhankelijkheid. Wat op een lokale computer werkt, werkt mogelijk niet op een productieserver.
- Langzame en resource-intensieve schaalvergroting van een oplossing voor virtuele machines.
Nginx-webserver met statische bestanden die op een virtuele machine worden uitgevoerd
Als containers worden gebruikt om een soortgelijk probleem op te lossen, dan zijn er in vergelijking met virtuele machines de volgende sterke punten:
- Efficiënt gebruik van bronnen: werk met het besturingssysteem met behulp van Docker.
- Platformonafhankelijkheid. Een container die een ontwikkelaar op zijn eigen computer kan draaien, draait overal.
- Lichtgewicht implementatie door het gebruik van afbeeldingslagen.
Nginx-webserver met statische bestanden die in een container worden uitgevoerd
We hebben alleen virtuele machines en containers op een paar punten vergeleken, maar zelfs dat is genoeg om een idee te krijgen van de sterke punten van containers. U kunt details vinden over Docker-containers.
▍Een containerimage bouwen voor een React-app
De basisbouwsteen van een Docker-container is het bestand Dockerfile. Aan het begin van dit bestand wordt een basisafbeelding van de container vastgelegd, waarna een reeks instructies wordt toegevoegd die aangeven hoe een container moet worden gemaakt die voldoet aan de behoeften van een toepassing.
Voordat we met het bestand gaan werken Dockerfile, onthoud wat we hebben gedaan om de bestanden van de React-applicatie voor te bereiden voor uploaden naar de Nginx-server:
- Een React-app-pakket bouwen (
npm run build). - De Nginx-server opstarten.
- De inhoud van een map kopiëren
builduit de projectmapsa-frontendnaar de servermapnginx/html.
Hieronder ziet u de parallellen tussen het maken van een container en de bovenstaande acties die op de lokale computer worden uitgevoerd.
▍Een Dockerfile voorbereiden voor de SA-Frontend-toepassing
Instructies die moeten worden opgenomen Dockerfile voor toepassing SA-Frontend, bestaan uit slechts twee commando's. Feit is dat het ontwikkelingsteam van Nginx een basis heeft voorbereid voor Nginx, die we zullen gebruiken om ons imago op te bouwen. Dit zijn de twee stappen die we moeten beschrijven:
- U moet de Nginx-afbeelding de basis van de afbeelding maken.
- Map inhoud
sa-frontend/buildmoet kopiëren naar de afbeeldingsmapnginx/html.
Als we van deze beschrijving naar het bestand gaan Dockerfile, dan ziet het er zo uit:
FROM nginx
COPY build /usr/share/nginx/html
Zoals u kunt zien, is alles hier heel eenvoudig, terwijl de inhoud van het bestand zelfs redelijk leesbaar en begrijpelijk blijkt te zijn. Dit bestand vertelt het systeem om de afbeelding te maken nginx met alles wat het al heeft, en kopieer de inhoud van de directory build naar de map nginx/html.
Hier heb je misschien een vraag over hoe ik weet waar ik de bestanden uit de map precies moet kopiëren build, d.w.z. waar kwam het pad vandaan /usr/share/nginx/html. In feite is er hier ook niets ingewikkelds. Feit is dat de relevante informatie te vinden is in beeld.
▍De afbeelding samenstellen en uploaden naar de repository
Voordat we met een voltooide afbeelding kunnen werken, moeten we deze indienen bij de afbeeldingsopslagplaats. Hiervoor gebruiken we het gratis cloudgebaseerde beeldhostingplatform Docker Hub. In deze werkfase moet u het volgende doen:
- Om te installeren .
- Registreer u op de Docker Hub-site.
- Log in op uw account door de volgende opdracht in de terminal uit te voeren:
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
Nu moet je met behulp van de terminal naar de directory gaan sa-frontend en voer daar het volgende commando uit:
docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .
Hier en hieronder in vergelijkbare opdrachten $DOCKER_USER_ID moet worden vervangen door uw gebruikersnaam op Docker Hub. Dit deel van de opdracht kan er bijvoorbeeld zo uitzien: rinormaloku/sentiment-analysis-frontend.
In dit geval kan dit commando worden ingekort door het te verwijderen -f Dockerfile, aangezien de map waarin we deze opdracht uitvoeren dit bestand al heeft.
Om de voltooide afbeelding naar de repository te sturen, hebben we de volgende opdracht nodig:
docker push $DOCKER_USER_ID/sentiment-analysis-frontendControleer na voltooiing uw lijst met opslagplaatsen op Docker Hub om te zien of de afbeelding met succes naar de cloudopslag is gepusht.
▍Starten van een container
Nu kan iedereen de afbeelding die bekend staat als $DOCKER_USER_ID/sentiment-analysis-frontend. Om dit te doen, moet u de volgende reeks opdrachten uitvoeren:
docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend
Nu draait de container en kunnen we doorgaan met het maken van andere afbeeldingen die we nodig hebben. Maar voordat we verder gaan, laten we het ontwerp begrijpen 80:80, die te vinden is in de opdracht om de afbeelding uit te voeren en die verwarrend kan lijken.
- Eerste nummer
80is het poortnummer van de host (dat wil zeggen, de lokale computer). - Tweede nummer
80is de poort van de container waarnaar het verzoek moet worden omgeleid.
Beschouw de volgende illustratie.
Port forwarding
Het systeem stuurt verzoeken van de poort door <hostPort> per poort <containerPort>. Dat wil zeggen, toegang tot de haven 80 computer wordt omgeleid naar een poort 80 container.
Sinds de haven 80 geopend op de lokale computer, kunt u vanaf deze computer toegang krijgen tot de toepassing op localhost:80. Als uw systeem Docker niet ondersteunt, kunt u de toepassing uitvoeren op een virtuele Docker-machine, waarvan het adres er als volgt uitziet <docker-machine ip>:80. Om het IP-adres van de virtuele Docker-machine te achterhalen, kunt u de opdracht gebruiken docker-machine ip.
Op dit punt, zodra de front-end app-container met succes is gelanceerd, zou u de pagina in een browser moeten kunnen openen.
▍.dockerignore-bestand
De applicatie-image bouwen SA-Frontend, konden we merken dat dit proces extreem traag is. Dit komt doordat de image-buildcontext naar de Docker-daemon moet worden verzonden. De map die de buildcontext vertegenwoordigt, wordt gegeven als het laatste argument voor de opdracht docker build. In ons geval staat er een punt aan het einde van dit commando. Dit resulteert erin dat de volgende structuur wordt opgenomen in de assemblagecontext:
sa-frontend:
| .dockerignore
| Dockerfile
| package.json
| README.md
+---build
+---node_modules
+---public
---src
Maar van alle mappen die hier aanwezig zijn, hebben we alleen een map nodig build. Al het andere downloaden is tijdverspilling. U kunt het bouwen versnellen door Docker te vertellen welke mappen moeten worden genegeerd. Hiervoor hebben we een dossier nodig .dockerignore. Jij, als je bekend bent met het dossier .gitignore, zal de structuur van dit bestand waarschijnlijk bekend voorkomen. Het vermeldt mappen die het systeem voor het maken van afbeeldingen kan negeren. In ons geval ziet de inhoud van dit bestand er als volgt uit:
node_modules
src
public
file .dockerignore moet zich in dezelfde map bevinden als het bestand Dockerfile. Nu duurt het samenstellen van de afbeelding enkele seconden.
Laten we nu de afbeelding voor een Java-toepassing behandelen.
▍Een containerimage bouwen voor een Java-toepassing
Weet je wat, en je hebt al alles geleerd wat je nodig hebt om container-images te maken. Daarom zal dit gedeelte erg kort zijn.
Open het bestand Dockerfile, die zich in de projectmap bevindt sa-webapp. Als u de tekst van dit bestand leest, zult u daarin slechts twee nieuwe constructies tegenkomen die beginnen met trefwoorden ENV и EXPOSE:
ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080
trefwoord ENV stelt u in staat omgevingsvariabelen in Docker-containers te declareren. In ons geval kunt u met name een URL instellen om toegang te krijgen tot de API van de applicatie die tekstanalyse uitvoert.
trefwoord EXPOSE kunt u Docker vertellen om een poort te openen. We gaan deze poort gebruiken terwijl we met de applicatie werken. Hier zie je dat in Dockerfile voor toepassing SA-Frontend zo'n bevel bestaat niet. Dit is alleen voor documentatiedoeleinden, met andere woorden, deze constructie is voor de lezer Dockerfile.
Het bouwen van de afbeelding en deze naar de repository pushen lijkt precies op het vorige voorbeeld. Als u nog niet helemaal zeker bent van uw kunnen, vindt u de bijbehorende commando's in het bestand README.md in map sa-webapp.
▍Een containerimage bouwen voor een Python-toepassing
Als je de inhoud van het bestand bekijkt Dockerfile in map sa-logicdaar vind je niets nieuws. De commando's voor het bouwen van de afbeelding en het naar de repository pushen zouden je al bekend moeten zijn, maar, net als in het geval van onze andere applicaties, zijn ze te vinden in het bestand README.md in map sa-logic.
▍Toepassingen in containers testen
Kun je iets vertrouwen dat je niet hebt getest? Ik kan het ook niet. Laten we onze containers testen.
- Laten we de toepassingscontainer starten
sa-logicen configureer het om op een poort te luisteren5050:docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic - Laten we de toepassingscontainer starten
sa-webappen configureer het om op een poort te luisteren8080. Bovendien moeten we de poort instellen waarop de Python-toepassing luistert naar verzoeken van de Java-toepassing door de omgevingsvariabele opnieuw toe te wijzenSA_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
Raadpleeg het bestand voor meer informatie over het achterhalen van het IP-adres van een container of Docker VM .
Laten we de toepassingscontainer 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 te navigeren localhost:80 en test de app.
Houd er rekening mee dat als u de poort wijzigt voor sa-webapp, of als u een Docker VM uitvoert, moet u het bestand bewerken App.js uit map sa-frontenddoor het IP-adres of poortnummer in de methode te wijzigen analyzeSentence()door actuele informatie te vervangen in plaats van verouderde data. Daarna moet u de afbeelding opnieuw in elkaar zetten en gebruiken.
Zo ziet ons applicatieschema er nu uit.
Microservices draaien in containers
Samenvatting: waarom hebben we een Kubernetes-cluster nodig?
We hebben zojuist de bestanden bekeken Dockerfile, spraken over het bouwen van afbeeldingen en deze naar een Docker-repository pushen. Bovendien hebben we geleerd hoe we het samenstellen van afbeeldingen kunnen versnellen met behulp van het bestand .dockerignore. Hierdoor draaien onze microservices nu in Docker-containers. Hier heb je misschien een volledig terechte vraag over waarom we Kubernetes nodig hebben. Het antwoord op deze vraag zal worden besteed aan het tweede deel van dit materiaal. Overweeg in de tussentijd de volgende vraag:
Laten we aannemen dat onze webapplicatie voor tekstanalyse wereldwijd populair is geworden. Miljoenen verzoeken komen elke minuut bij hem binnen. Dit betekent dat microservices sa-webapp и sa-logic zal enorm onder druk komen te staan. Hoe schaal je containers die microservices uitvoeren?
Bron: www.habr.com