🥇Kubernetes-Leitfaden, Teil 1: Anwendungen, Mikrodienste und Container

Auf unsere Bitte hat Habr einen Hub erstellt Kubernetes und wir freuen uns, die erste Veröffentlichung darin zu platzieren. Abonnieren Sie!

Kubernetes ist einfach. Warum zahlen mir Banken große Summen für die Arbeit in diesem Bereich, während jeder diese Technologie buchstäblich in wenigen Stunden erlernen kann?

Wenn Sie Zweifel haben, dass Kubernetes so schnell zu erlernen ist, lade ich Sie ein, es selbst zu versuchen. Indem Sie dieses Material durchgehen, werden Sie in der Lage sein, eine mikroservicebasierte Anwendung in einem Kubernetes-Cluster zu starten. Das garantiere ich, denn genau nach dieser Methode, die hier verwendet wird, bringe ich unseren Kunden den Umgang mit Kubernetes bei. Was unterscheidet dieses Handbuch von anderen? Tatsächlich gibt es viele Unterschiede. Die meisten ähnlichen Materialien beginnen mit der Erklärung einfacher Dinge – der Konzepte von Kubernetes und den Besonderheiten des Befehls kubectl. Die Autoren dieser Materialien nehmen an, dass ihre Leser mit der Anwendungsentwicklung, mit Mikrodiensten und mit Docker-Containern vertraut sind. Wir hingegen werden einen anderen Weg gehen. Zuerst werden wir erläutern, wie man eine mikroservicebasierte Anwendung auf dem Computer startet. Dann betrachten wir den Aufbau von Container-Images für jeden Mikrodienst. Und erst danach machen wir uns mit Kubernetes vertraut und analysieren die Bereitstellung der mikrosservice-basierten Anwendung in einem von Kubernetes verwalteten Cluster.

Dieser Ansatz, schrittweise auf Kubernetes zuzugehen, wird die Tiefe des Verständnisses vermitteln, die ein gewöhnlicher Mensch braucht, um zu begreifen, wie einfach Kubernetes funktioniert. Kubernetes ist zweifellos eine einfache Technologie, vorausgesetzt, derjenige, der sie erlernen möchte, weiß, wo und wie sie eingesetzt wird.

Jetzt, ohne weitere Umschweife, lassen Sie uns mit der Arbeit beginnen und über die Anwendung sprechen, mit der wir arbeiten werden.

Experimentieranwendung

Unsere Anwendung wird nur eine Funktion erfüllen. Sie nimmt als Eingabe einen Satz und führt dann mithilfe von Textanalyse-Tools eine Sentiment-Analyse dieses Satzes durch, um die emotionale Haltung des Autors gegenüber einem bestimmten Objekt zu bewerten.

So sieht das Hauptfenster dieser Anwendung aus.

Webanwendung zur Analyse der Sentimente von Texten

Aus technischer Sicht besteht die Anwendung aus drei Mikrodiensten, von denen jeder einen bestimmten Satz von Aufgaben löst:

SA-Frontend – ein Nginx-Webserver, der statische React-Dateien bedient.
SA-WebApp – eine in Java geschriebene Webanwendung, die Anfragen vom Frontend verarbeitet.
SA-Logic – eine Python-Anwendung, die die Textsentimentanalyse durchführt.

Es ist wichtig zu beachten, dass die Mikrodienste nicht isoliert existieren. Sie implementieren die Idee der "Aufgabenteilung", müssen aber dennoch miteinander interagieren.

Datenströme in der Anwendung

In dem oben dargestellten Diagramm sind die nummerierten Systemarbeitsphasen zu sehen, die die Datenströme in der Anwendung illustrieren. Lassen Sie uns diese näher betrachten:

Der Browser fordert eine Datei vom Server an index.html (der seinerseits das Paket der React-Anwendung herunterlädt).
Der Benutzer interagiert mit der Anwendung, was eine Anfrage an die auf Spring basierende Webanwendung auslöst.
Die Webanwendung leitet die Anfrage zur Durchführung der Textanalyse an die Python-Anwendung weiter.
Die Python-Anwendung führt die Textsentimentanalyse durch und gibt das Ergebnis als Antwort auf die Anfrage zurück.
Die Spring-Anwendung sendet die Antwort an die React-Anwendung (die ihrerseits das Ergebnis der Textanalyse dem Benutzer anzeigt).

Der Code für all diese Anwendungen ist zu finden hier. Ich empfehle Ihnen, dieses Repository jetzt sofort zu kopieren, da uns viele interessante Experimente damit bevorstehen.

Start der auf Mikrodiensten basierenden Anwendung auf dem lokalen Computer

Damit die Anwendung funktioniert, müssen alle drei Mikrodienste gestartet werden. Beginnen wir mit dem ansprechendsten von ihnen – der Frontend-Anwendung.

▍Einrichten von React für die lokale Entwicklung

Um die React-Anwendung zu starten, müssen Sie die Node.js- und NPM-Plattform auf Ihrem Computer installieren. Nachdem Sie dies installiert haben, wechseln Sie über das Terminal in den Projektordner sa-frontend und führen Sie den folgenden Befehl aus:

npm install

Durch die Ausführung dieses Befehls werden die Abhängigkeiten der React-Anwendung in den Ordner node_modules geladen, deren Aufzeichnungen sich in der Datei package.jsonbefinden. Nachdem die Abhängigkeiten heruntergeladen wurden, führen Sie im selben Ordner den folgenden Befehl aus:

npm start

Das ist alles. Jetzt ist die React-Anwendung gestartet, und Sie können über den Browser darauf zugreifen, indem Sie die Adresse aufrufen. localhost:3000. Sie können etwas in seinem Code ändern. Die Auswirkungen dieser Änderungen sehen Sie sofort im Browser. Dies ist dank der sogenannten „Hot-Module-Replacement“ möglich. Dadurch wird die Frontend-Entwicklung zu einer einfachen und angenehmen Aufgabe.

▍Vorbereitung der React-Anwendung für die Produktion

Für den Einsatz einer React-Anwendung müssen wir sie in eine Sammlung statischer Dateien umwandeln und diese über einen Webserver an die Clients ausliefern.

Um die React-Anwendung zu bauen, gehen Sie erneut über das Terminal in den Ordner sa-frontend und führen Sie den folgenden Befehl aus:

npm run build

Dies führt zur Erstellung eines Verzeichnisses im Projektordner build. Darin befinden sich alle statischen Dateien, die zum Betrieb der React-Anwendung erforderlich sind.

▍Bereitstellung statischer Dateien mit Nginx

Zuerst müssen Sie den Webserver Nginx installieren und starten. Hier Sie können es herunterladen und Anweisungen zur Installation und zum Start finden. Dann müssen Sie den Inhalt des Ordners sa-frontend/build in den Ordner [your_nginx_installation_dir]/html.

Mit diesem Ansatz wird die im Build-Prozess der React-Anwendung generierte Datei index.html unter der Adresse verfügbar sein [your_nginx_installation_dir]/html/index.html. Dies ist die Datei, die standardmäßig vom Nginx-Server bei Zugriff darauf ausgegeben wird. Der Server ist so konfiguriert, dass er den Port 80lauscht, aber Sie können ihn nach Ihren Wünschen anpassen, indem Sie die Datei [your_nginx_installation_dir]/conf/nginx.conf.

Jetzt öffnen Sie den Browser und gehen zu der Adresse localhost:80. Sie sehen die Seite der React-Anwendung.

React-Anwendung, die vom Nginx-Server bereitgestellt wird

Wenn Sie jetzt etwas in das Feld Type your sentence eingeben und auf die Schaltfläche Send klicken, wird nichts passieren. Aber wenn Sie die Konsole öffnen, können Sie Fehlermeldungen sehen. Um zu verstehen, wo genau diese Fehler auftreten, analysieren wir den Anwendungscode.

▍Analyse des Frontend-Anwendungscodes

Wenn wir uns den Code der Datei App.jsansehen, sehen wir, dass das Klicken auf die Schaltfläche Send anschauen, können wir sehen, dass das Drücken der Schaltfläche analyzeSentence(). Der Code dieser Methode wird unten angegeben. Beachten Sie dabei, dass jede Zeile, die einen Kommentar in der Form # Номерhat, eine Erklärung unten im Code hat. Auf die gleiche Weise werden wir auch andere Codeabschnitte analysieren.

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. Die URL, unter der die POST-Anfrage ausgeführt wird. Es wird davon ausgegangen, dass sich unter dieser Adresse eine Anwendung befindet, die solche Anfragen erwartet.

2.Der Anfrageinhalt, der an die Anwendung gesendet wird. Hier ist ein Beispiel für den Anfrageinhalt:

{
    sentence: "I like yogobella!"
}

3.Beim Empfang der Antwort auf die Anfrage wird der Zustand der Komponente aktualisiert. Dies führt zu einem erneuten Rendering der Komponente. Wenn wir Daten erhalten (d. h. ein JSON-Objekt, das die eingegebenen Daten und die berechnete Bewertung des Textes enthält), geben wir die Komponente aus Polarity, da die entsprechenden Bedingungen erfüllt sind. So beschreiben wir die Komponente:

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

Der Code sieht soweit funktionsfähig aus. Was ist hier also nicht in Ordnung? Wenn Sie annehmen, dass unter der Adresse, zu der die Anwendung versucht, die POST-Anfrage zu senden, noch nichts vorhanden ist, was diese Anfrage annehmen und verarbeiten kann, dann haben Sie absolut recht. Nämlich, um Anfragen zu verarbeiten, die an die Adresse http://localhost:8080/sentiment, müssen wir eine auf Spring basierende Webanwendung starten.

Wir benötigen eine Spring-Anwendung, die POST-Anfragen annehmen kann.

▍Einrichten der auf Spring basierenden Webanwendung

Um eine Spring-Anwendung bereitzustellen, benötigen Sie JDK8 und Maven sowie korrekt konfigurierte Umgebungsvariablen. Nachdem Sie all dies installiert haben, können Sie mit unserem Projekt fortfahren.

▍Anwendung in eine Jar-Datei verpacken

Wechseln Sie über das Terminal in den Ordner sa-webapp und geben Sie den folgenden Befehl ein:

mvn install

Nach dem Ausführen dieses Befehls wird im Ordner sa-webapp ein Verzeichnis erstellt werden. targetHier wird sich die Java-Anwendung befinden, die in eine Jar-Datei verpackt ist, dargestellt durch die Datei sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Java-Anwendung starten

Wechseln Sie in den Ordner target und starten Sie die Anwendung mit dem folgenden Befehl:

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

Bei der Ausführung dieses Befehls wird ein Fehler auftreten. Um mit der Behebung zu beginnen, können wir die Ausnahmeinformationen in den Stack-Trace-Daten analysieren:

Fehler beim Erstellen der Bean mit dem Namen 'sentimentController': Injection der autowired Abhängigkeiten fehlgeschlagen; verschachtelte Ausnahme ist java.lang.IllegalArgumentException: Platzhalter 'sa.logic.api.url' konnte in Wert "${sa.logic.api.url}" nicht aufgelöst werden.

Für uns ist hier das Wichtigste die Erwähnung der Unmöglichkeit, den Wert zu ermitteln. sa.logic.api.url. Lassen Sie uns den Code analysieren, in dem der Fehler auftritt.

▍Analyse des Java-Anwendungs-Codes

Hier ist der Codeausschnitt, in dem der Fehler auftritt.

@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 SentimentController gibt es ein Feld saLogicApiUrl. Sein Wert wird durch die Eigenschaft festgelegt sa.logic.api.url.
Zeichenkette saLogicApiUrl konkateniert mit dem Wert /analyse/sentiment. Gemeinsam bilden sie die Adresse, um den Microservice anzusprechen, der die Textanalyse durchführt.

▍Wertzuweisung für die Eigenschaft

In Spring ist die Standardquelle für Eigenschaftswerte die Datei application.properties, die Sie finden können unter sa-webapp/src/main/resources. Aber die Verwendung ist nicht die einzige Möglichkeit, Werte für Eigenschaften festzulegen. Sie können dies auch mit einem Befehl wie folgt tun:

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

Der Wert dieser Eigenschaft sollte auf die Adresse unserer Python-Anwendung verweisen.

Durch die Konfiguration teilen wir der Webanwendung Spring mit, wohin sie für Anfragen zur Textanalyse gehen muss.

Um uns das Leben nicht zu erschweren, gehen wir davon aus, dass die Python-Anwendung unter der Adresse verfügbar ist localhost:5000 und versuchen, das nicht zu vergessen. Daher wird der Befehl zum Starten der Spring-Anwendung so aussehen:

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

In unserem System fehlt die Python-Anwendung.

Jetzt müssen wir nur noch die Python-Anwendung starten und das System wird so funktionieren, wie erwartet.

▍Konfiguration der Python-Anwendung

Um die Python-Anwendung zu starten, müssen Python 3 und Pip installiert sein und die entsprechenden Umgebungsvariablen müssen korrekt konfiguriert sein.

▍Installation der Abhängigkeiten

Wechseln Sie in das Projektverzeichnis sa-logic/sa und führen Sie die folgenden Befehle aus:

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

▍Start der Anwendung

Nach der Installation der Abhängigkeiten sind wir bereit, die Anwendung zu starten:

python sentiment_analysis.py

Nach der Ausführung dieses Befehls erhalten wir folgende Mitteilung:

* Läuft auf http://0.0.0.0:5000/ (Drücken Sie CTRL+C zum Beenden)

Das bedeutet, dass die Anwendung gestartet ist und auf Anfragen an folgende Adresse wartet: localhost:5000/

▍Code-Analyse

Betrachten wir den Python-Anwendungscode, um zu verstehen, wie sie auf Anfragen reagiert:

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

Initialisierung des Objekts Flask.
Festlegen der Adresse für das Senden von POST-Anfragen.
Extrahieren der Eigenschaft sentence aus dem Anfragetext.
Initialisierung des anonymen Objekts TextBlob und Abrufen des Wertes polarity für den ersten im Anfragekörper übermittelten Satz (in unserem Fall handelt es sich um den einzigen Satz, der zur Analyse übergeben wird).
Rückgabe einer Antwort, deren Körper den Text des Satzes und den berechneten Wert enthält. polarity.
Starten der Flask-Anwendung, die unter folgender Adresse verfügbar sein wird: 0.0.0.0:5000 (sie kann auch über die folgende Struktur aufgerufen werden: localhost:5000).

Jetzt sind die Mikrodienste, aus denen die Anwendung besteht, gestartet. Sie sind so konfiguriert, dass sie miteinander interagieren. So sieht das Anwendungsschema in diesem Arbeitsschritt aus.

Alle Mikrodienste, aus denen die Anwendung besteht, sind betriebsbereit.

Jetzt, bevor Sie fortfahren, öffnen Sie die React-Anwendung im Browser und versuchen Sie, mit ihrer Hilfe einen Satz zu analysieren. Wenn alles richtig gemacht wurde — nachdem Sie auf die Schaltfläche gedrückt haben, Send werden Sie die Analyseergebnisse unter dem Texteingabefeld sehen.

Im nächsten Abschnitt werden wir besprechen, wie wir unsere Mikrodienste in Docker-Containern starten können. Dies ist notwendig, um die Anwendung für den Einsatz in einem Kubernetes-Cluster vorzubereiten.

Docker-Container

Kubernetes — dies ist ein System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen. Es wird auch als „Container-Orchestrator“ bezeichnet. Wenn Kubernetes mit Containern arbeitet, müssen wir uns, bevor wir dieses System nutzen, zunächst diese Container beschaffen. Aber zuerst lassen Sie uns darüber sprechen, was Container sind. Die beste Antwort auf die Frage, was das ist, findet man in Dokumentation Docker:

Ein Container-Abbild ist ein leichtgewichtiger, eigenständiger, ausführbarer Paket, das eine Anwendung enthält und alles Notwendige für deren Ausführung umfasst: den Anwendungscode, die Laufzeitumgebung, Systemwerkzeuge und Bibliotheken, Konfigurationen. Containerisierte Programme können sowohl in Linux- als auch in Windows-Umgebungen verwendet werden und funktionieren dabei immer gleich, unabhängig von der Infrastruktur.

Das bedeutet, dass Container auf beliebigen Computern ausgeführt werden können, einschließlich Produktionsservern, und die darin enthaltenen Anwendungen in jeder Umgebung gleich funktionieren werden.

Um die Besonderheiten von Containern zu untersuchen und sie mit anderen Möglichkeiten zur Ausführung von Anwendungen zu vergleichen, betrachten wir ein Beispiel für das Management einer React-Anwendung unter Verwendung einer virtuellen Maschine und eines Containers.

▍Verwaltung statischer Dateien einer React-Anwendung mittels virtueller Maschinen

Wenn wir versuchen, die Bereitstellung statischer Dateien mit virtuellen Maschinen zu organisieren, stoßen wir auf folgende Nachteile:

Ineffiziente Ressourcennutzung, da jede virtuelle Maschine ein vollständiges Betriebssystem darstellt.
Abhängigkeit von der Plattform. Was auf einem bestimmten lokalen Computer funktioniert, könnte auf einem Produktionsserver möglicherweise nicht funktionieren.
Langsame und ressourcenintensive Skalierung einer auf virtuellen Maschinen basierenden Lösung.

Webserver Nginx, der statische Dateien bereitstellt, der auf einer virtuellen Maschine ausgeführt wird

Wenn wir jedoch für die Lösung einer ähnlichen Aufgabe Container verwenden, lassen sich im Vergleich zu virtuellen Maschinen folgende Stärken verzeichnen:

Effiziente Ressourcennutzung: Arbeiten mit dem Betriebssystem über Docker.
Unabhängigkeit von Plattformen. Der Container, den der Entwickler auf seinem Computer ausführen kann, wird überall funktionieren.
Leichtgewichtige Bereitstellung durch die Nutzung von Schichten von Images.

Webserver Nginx, der statische Dateien bedient, wurde im Container gestartet

Wir haben virtuelle Maschinen und Container nur anhand weniger Punkte verglichen, aber selbst das reicht aus, um die Stärken von Containern zu spüren. Hier Details zu Docker-Containern finden Sie hier.

▍Erstellen Sie das Container-Image für die React-Anwendung

Der grundlegende Baustein eines Docker-Containers ist die Datei Dockerfile. Am Anfang dieser Datei wird das Basis-Image des Containers angegeben, danach folgt eine Reihe von Anweisungen, die die Reihenfolge zur Erstellung des Containers angeben, die den Anforderungen einer bestimmten Anwendung entspricht.

Bevor wir mit der Arbeit an der Datei beginnen Dockerfile, erinnern wir uns, was wir getan haben, um die Dateien der React-Anwendung für das Hosten auf dem Nginx-Server vorzubereiten:

Bauen des React-Anwendungspakets (npm run build).
Starten des Nginx-Servers.
Inhalt des Verzeichnisses build aus dem Projektverzeichnis sa-frontend in den Serverordner nginx/html.

Unten sehen Sie die Parallelen zwischen der Erstellung des Containers und den oben beschriebenen Aktionen, die auf dem lokalen Computer durchgeführt werden.

▍Vorbereitung der Dockerfile für die SA-Frontend-Anwendung

Die Anweisungen, die in enthalten sind Dockerfile für die Anwendung SA-Frontend, bestehen aus nur zwei Befehlen. Der Grund ist, dass die Nginx-Entwickler ein Basis- Image für Nginx vorbereitet haben, das wir verwenden werden, um unser Image zu erstellen. Hier sind die beiden Schritte, die wir beschreiben müssen:

Das Basis-Image muss das Nginx-Image sein.
Der Inhalt des Ordners sa-frontend/build muss in den Image-Ordner kopiert werden. nginx/html.

Wenn wir von dieser Beschreibung zur Datei übergehen Dockerfile, wird sie so aussehen:

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

Wie Sie sehen, ist alles sehr einfach, und der Inhalt der Datei ist sogar recht lesbar und verständlich. Diese Datei sagt dem System, dass es das Image nginx mit allem, was bereits darin ist, nehmen und den Inhalt des Verzeichnisses build in das Verzeichnis nginx/html.

kopieren soll. Hier könnte sich die Frage stellen, woher ich weiß, wohin genau die Dateien aus dem Ordner kopiert werden sollen, buildalso woher der Pfad stammt /usr/share/nginx/html. Tatsächlich gibt es auch hier nichts Kompliziertes. Die entsprechenden Informationen finden sich in Beschreibung des Images.

▍Erstellen eines Images und Hochladen in das Repository

Bevor wir mit dem bereitgestellten Bild arbeiten können, müssen wir es in das Image-Repository hochladen. Dazu verwenden wir die kostenlose Cloud-Plattform Docker Hub für das Hosting von Images. In diesem Arbeitsabschnitt müssen Sie Folgendes tun:

Installieren Docker.
Registrieren Sie sich auf der Website Docker Hub.
Melden Sie sich mit folgendem Befehl im Terminal bei Ihrem Konto an:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Jetzt müssen wir über das Terminal in das Verzeichnis wechseln sa-frontend und dort folgenden Befehl ausführen:

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

Hier und in ähnlichen Befehlen $DOCKER_USER_ID muss durch Ihren Benutzernamen auf Docker Hub ersetzt werden. Zum Beispiel könnte dieser Teil des Befehls so aussehen: rinormaloku/sentiment-analysis-frontend.

Dabei kann der Befehl verkürzt werden, indem -f Dockerfileentfernt wird, da sich diese Datei bereits im Verzeichnis befindet, in dem wir diesen Befehl ausführen.

Um das fertige Image in das Repository hochzuladen, benötigen wir folgenden Befehl:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Nachdem Sie diesen Befehl ausgeführt haben, überprüfen Sie die Liste Ihrer Repositories auf Docker Hub, um festzustellen, ob der Upload des Images in die Cloud-Speicher erfolgreich war.

▍Container starten

Nun kann jeder das Image herunterladen und starten, das als $DOCKER_USER_ID/sentiment-analysis-frontendbekannt ist. Um dies zu tun, müssen Sie die folgende Befehlsfolge ausführen:

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

Jetzt läuft der Container und wir können mit der Erstellung weiterer benötigter Images fortfahren. Aber bevor wir weitermachen, lassen Sie uns die Struktur 80:80, die im Startbefehl des Images vorkommt, näher betrachten, da sie möglicherweise unklar erscheint.

Die erste Zahl 80 ist die Portnummer des Hosts (d.h. des lokalen Computers).
Die zweite Zahl 80 ist der Port des Containers, auf den die Anfrage weitergeleitet werden soll.

Betrachten wir die folgende Illustration.

Portweiterleitung

Das System leitet Anfragen vom Port <hostPort> zum Port <containerPort>. Das bedeutet, dass eine Anfrage an den Port 80 des Computers auf den Port 80 des Containers weitergeleitet wird.

Da der Port 80 auf dem lokalen Computer geöffnet ist, kann die Anwendung von diesem Computer aus unter der Adresse aufgerufen werden. localhost:80. Wenn Ihr System Docker nicht unterstützt, kann die Anwendung auf einer Docker-virtuellen Maschine gestartet werden, deren Adresse wie folgt aussieht :80. Um die IP-Adresse der Docker-virtuellen Maschine herauszufinden, können Sie den Befehl docker-machine ip.

In diesem Stadium sollten Sie nach erfolgreichem Start des Frontend-Anwendungcontainers in der Lage sein, die Seite im Browser zu öffnen.

▍Datei .dockerignore

Beim Erstellen des Anwendungs-Images SA-Frontend, haben wir bemerkt, dass dieser Prozess äußerst langsam ist. Das liegt daran, dass der Docker-Dämon den Kontext für den Image-Bau erhalten muss. Verzeichnis, das den Baukontext darstellt, wird durch das letzte Argument des Befehls festgelegt docker build. In unserem Fall steht am Ende dieses Befehls ein Punkt. Das führt dazu, dass die folgende Struktur in den Baukontext einbezogen wird:

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

Aber wir brauchen von all diesen hier vorhandenen Ordnern nur den Ordner build. Es ist eine Zeitverschwendung, alles andere zu laden. Der Bau kann beschleunigt werden, indem man Docker angibt, welche Verzeichnisse ignoriert werden können. Genau dafür benötigen wir die Datei .dockerignore. Wenn Sie mit der Datei vertraut sind, wird Ihnen die Struktur dieser Datei sicherlich vertraut vorkommen. Sie listet die Verzeichnisse auf, die das Image-Bausystem ignorieren kann. In unserem Fall sieht der Inhalt dieser Datei so aus: .gitignorenode_modules src public

muss sich im gleichen Verzeichnis befinden wie die Datei

Die Datei .dockerignore . Jetzt wird der Bau des Images nur noch wenige Sekunden in Anspruch nehmen. DockerfileKümmern wir uns jetzt um das Image für die Java-Anwendung.

▍Bau des Container-Images für die Java-Anwendung

Wissen Sie was? Sie haben bereits alles Notwendige zum Erstellen von Container-Images gelernt. Deshalb wird dieser Abschnitt sehr kurz sein.

, die sich im Projektverzeichnis befindet

Öffnen Sie die Datei Dockerfile. Wenn Sie den Text dieser Datei lesen, werden Sie nur zwei neue Konstruktionen finden, die mit den Schlüsselwörtern beginnen sa-webappENV SA_LOGIC_API_URL http://localhost:5000 … EXPOSE 8080 ENV und EXPOSE:

Das Schlüsselwort

ermöglicht es, Umgebungsvariablen innerhalb von Docker-Containern zu deklarieren. In unserem Fall ermöglicht es, die URL für den Zugriff auf die API der Anwendung, die Textanalysen durchführt, festzulegen. ENV ermöglicht die Deklaration von Umgebungsvariablen innerhalb von Docker-Containern. Insbesondere in unserem Fall ermöglicht es, die URL für den Zugriff auf die API der Anwendung, die die Textanalyse durchführt, festzulegen.

ermöglicht es, Umgebungsvariablen innerhalb von Docker-Containern zu deklarieren. In unserem Fall ermöglicht es, die URL für den Zugriff auf die API der Anwendung, die Textanalysen durchführt, festzulegen. EXPOSE erlaubt es Docker anzugeben, dass der Port geöffnet werden soll. Wir planen, diesen Port während der Arbeit mit der Anwendung zu nutzen. Hier ist zu beachten, dass in Dockerfile für die Anwendung SA-Frontend einem solchen Befehl nicht vorhanden ist. Dies ist nur für Dokumentationszwecke erforderlich, mit anderen Worten, diese Konstruktion ist für diejenigen gedacht, die lesen werden, Dockerfile.

Der Bau des Images und das Senden an das Repository sieht genau so aus wie im vorherigen Beispiel. Wenn Sie also noch nicht ganz sicher in Ihren Fähigkeiten sind – die entsprechenden Befehle finden Sie in der Datei README.md im Ordner sa-webapp.

▍Bau des Container-Images für eine Python-Anwendung

Wenn Sie den Inhalt der Datei ansehen, Dockerfile im Ordner sa-logic, werden Sie dort nichts Neues entdecken. Die Befehle zum Bauen des Images und zum Senden an das Repository sollten Ihnen ebenfalls bereits bekannt sein, aber sie sind, wie auch bei unseren anderen Anwendungen, in der Datei zu finden README.md im Ordner sa-logic.

▍Testen von containerisierten Anwendungen

Können Sie etwas vertrauen, das Sie nicht getestet haben? Ich auch nicht. Lassen Sie uns unsere Container testen.

Wir starten den Anwendungscontainer sa-logic und konfigurieren ihn, um auf Port zu hören 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Wir starten den Anwendungscontainer sa-webapp und konfigurieren ihn, um auf Port zu hören 8080. Darüber hinaus müssen wir den Port konfigurieren, an dem die Python-Anwendung auf Anfragen von der Java-Anwendung warten wird, indem wir die Umgebungsvariable umbenennen SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

Um herauszufinden, wie Sie die IP-Adresse des Containers oder der Docker-VM ermitteln, schauen Sie in die Datei README.

Wir starten den Anwendungscontainer sa-frontend:

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

Jetzt ist alles bereit, um im Browser die Adresse aufzurufen localhost:80 und die Anwendung zu testen.

Beachten Sie, dass Sie, wenn Sie den Port für sa-webapp, geändert haben oder wenn Sie mit einer Docker-VM arbeiten, die Datei bearbeiten müssen App.js aus dem Ordner sa-frontend, indem Sie die IP-Adresse oder die Portnummer in der Methode ändern analyzeSentence(), und die veralteten Daten durch aktuelle Informationen ersetzen. Danach müssen Sie das Image erneut bauen und verwenden.

So sieht das Schema unserer Anwendung jetzt aus.

Mikroservices laufen in Containern

Zusammenfassung: Warum brauchen wir einen Kubernetes-Cluster?

Gerade haben wir die Dateien untersucht Dockerfile, darüber gesprochen, wie man Images baut und an das Docker-Repository sendet. Außerdem haben wir gelernt, den Bau von Images zu beschleunigen, indem wir die Datei verwenden. .dockerignore. Am Ende laufen unsere Mikrodienste jetzt in Docker-Containern. Hier könnte eine sehr berechtigte Frage aufkommen, warum wir Kubernetes brauchen. Die Antwort auf diese Frage wird Teil zwei dieses Materials gewidmet sein. Überlegen Sie in der Zwischenzeit die folgende Frage:
Angenommen, unsere Webanwendung zur Textanalyse ist weltweit beliebt geworden. Jede Minute kommen Millionen von Anfragen. Das bedeutet, dass die Mikrodienste sa-webapp und sa-logic einer enormen Belastung ausgesetzt sein werden. Wie skalieren wir die Container, in denen die Mikrodienste ausgeführt werden?

Quelle: habr.com