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

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

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

Falls Sie daran zweifeln, dass man Kubernetes so schnell erlernen kann – versuchen Sie es selbst. Mit diesem Material werden Sie in der Lage sein, eine auf Mikrodiensten basierende Anwendung in einem Kubernetes-Cluster zu starten. Ich kann das garantieren, denn genau nach dieser Methodik, die hier verwendet wird, schule ich unsere Kunden im Umgang mit Kubernetes. Was unterscheidet dieses Handbuch von anderen? Tatsächlich vieles. Die meisten vergleichbaren Materialien beginnen mit einfachen Erklärungen – den Konzepten von Kubernetes und der Funktionsweise des Befehls kubectl. Die Autoren dieser Materialien gehen davon aus, dass ihre Leser mit der Anwendungsentwicklung, Mikrodiensten und Docker-Containern vertraut sind. Wir hingegen schlagen einen anderen Weg ein. Zunächst erklären wir, wie man auf dem Computer eine auf Mikrodiensten basierende Anwendung startet. Dann betrachten wir den Aufbau von Container-Images für jeden Mikrodienst. Und erst danach lernen wir Kubernetes kennen und beschäftigen uns mit dem Deployment der auf Mikrodiensten basierenden Anwendung in einem von Kubernetes verwalteten Cluster.

Dieser Ansatz, der schrittweise auf Kubernetes zugeht, bietet das notwendige Verständnis für das, was geschieht, und ermöglicht es einem durchschnittlichen Menschen, die einfache Struktur von Kubernetes zu begreifen. Kubernetes ist in der Tat eine unkomplizierte Technologie, solange derjenige, der sie erlernen möchte, weiß, wo und wie sie eingesetzt wird.

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

Experimentelle Anwendung

Unsere Anwendung wird nur eine Funktion erfüllen. Sie nimmt einen Satz als Eingabe und analysiert diesen Satz mittels einer Sentiment-Analyse, um die emotionale Einstellung des Autors gegenüber einem bestimmten Objekt zu bewerten.

So sieht das Hauptfenster dieser Anwendung aus.

Webanwendung zur Analyse von Textstimmungen

Aus technischer Sicht besteht die Anwendung aus drei Microservices, 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 Sentiment-Analyse von Texten durchführt.

Es ist wichtig zu beachten, dass Mikrodienste nicht isoliert existieren. Sie realisieren das Konzept der "Trennung von Verantwortlichkeiten", müssen aber gleichzeitig miteinander interagieren.

Datenflüsse in der Anwendung

In dem obigen Diagramm sind die nummerierten Schritte des Systembetriebs zu sehen, die die Datenflüsse in der Anwendung veranschaulichen. Lassen Sie uns diese genauer betrachten:

Der Browser fragt eine Datei vom Server an index.html (die wiederum das Laden des React-Anwendungs-Pakets auslöst).
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 Sentiment-Analyse des Textes durch und gibt das Ergebnis als Antwort auf die Anfrage zurück.
Die Spring-Anwendung sendet die Antwort an die React-Anwendung (die wiederum das Analyseergebnis dem Benutzer anzeigt).

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

Starten einer mikroservicesbasierten Anwendung auf Ihrem lokalen Computer

Um die Anwendung zum Laufen zu bringen, müssen wir alle drei Microservices starten. Beginnen wir mit dem ansprechendsten von ihnen – der Frontend-Anwendung.

▍React für die lokale Entwicklung einrichten

Um die React-Anwendung zu starten, müssen Sie Node.js und NPM auf Ihrem Computer installieren. Nachdem Sie alles installiert haben, wechseln Sie im 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 heruntergeladen, die im Datei package.jsonaufgelistet sind. Nach dem Abschluss des Downloads führen Sie im selben Ordner den folgenden Befehl aus:

npm start

Das war's. Jetzt ist die React-Anwendung gestartet, auf die Sie über den Browser unter der Adresse localhost:3000 zugreifen können.. Sie können Änderungen am Code vornehmen. Die Auswirkungen dieser Änderungen werden Sie sofort im Browser sehen. Das ist möglich durch die sogenannte „Hot Module Replacement“-Technologie. Dadurch wird die Frontend-Entwicklung zu einer einfachen und angenehmen Aufgabe.

▍Vorbereitung der React-Anwendung für den Produktionsbetrieb

Um eine React-Anwendung für den tatsächlichen Einsatz vorzubereiten, müssen wir sie in eine Sammlung statischer Dateien umwandeln und diese über einen Webserver an die Clients ausliefern.

Für den Build der React-Anwendung wechseln Sie erneut ins Terminal und gehen Sie in das Verzeichnis sa-frontend und führen Sie den folgenden Befehl aus:

npm run build

Das führt zur Erstellung eines Verzeichnisses im Projektordner build. Dort finden Sie alle statischen Dateien, die für das Funktionieren der React-Anwendung erforderlich sind.

▍Bereitstellung statischer Dateien mit Nginx

Zunächst müssen Sie den Nginx-Webserver installieren und starten. Hier Sie können ihn 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 während des Builds 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 ausgegeben wird, wenn sie aufgerufen wird. Der Server ist so konfiguriert, dass er den Port 80, aber er kann so angepasst werden, wie Sie es benötigen, indem Sie die Datei [your_nginx_installation_dir]/conf/nginx.conf.

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

React-Anwendung, die vom Nginx-Server bedient wird

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

▍Analyse des Frontend-Anwendungscodes

Wenn wir den Code der Datei App.js, betrachten, können wir sehen, dass das Drücken der Taste Send die Methode analyzeSentence(). Der Code dieser Methode ist unten aufgeführt. Beachten Sie dabei, dass jede Zeile, die einen Kommentar des Typs # Номер, eine Erklärung enthält, die unter dem Code gegeben wird. Auf die gleiche Weise werden wir auch andere Fragmenten des Codes 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, an die die POST-Anfrage gesendet wird. Es wird vorausgesetzt, dass sich an dieser Adresse eine Anwendung befindet, die solche Anfragen erwartet.

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

{
    sentence: "Ich mag yogobella!"
}

3.Wenn eine Antwort auf die Anfrage empfangen wird, wird der Zustand der Komponente aktualisiert. Dies führt zu einem erneuten Rendern der Komponente. Wenn wir Daten erhalten (d. h. ein JSON-Objekt, das die eingegebenen Daten und die berechnete Textbewertung enthält), zeigen wir die Komponente an. Polarität, da die entsprechenden Bedingungen erfüllt sind. So beschreiben wir die Komponente:

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

Der Code scheint funktionstüchtig zu sein. Was könnte hier also nicht stimmen? Wenn Sie annehmen, dass an der Adresse, an die die Anwendung versucht, eine POST-Anfrage zu senden, noch nichts vorhanden ist, das diese Anfrage annehmen und verarbeiten kann, liegen Sie völlig richtig. Genauer gesagt, um die Anfragen zu bearbeiten, die an die Adresse kommen, http://localhost:8080/sentiment, müssen wir eine auf Spring basierende Webanwendung starten.

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

▍Einrichtung der auf Spring basierenden Webanwendung

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

▍Verpackung der Anwendung in eine jar-Datei

Navigieren Sie mit dem Terminal in den Ordner sa-webapp und geben Sie den folgenden Befehl ein:

mvn install

Nach der Ausführung dieses Befehls wird im Ordner sa-webapp ein Verzeichnis erstellt werden target. Hier wird sich die Java-Anwendung befinden, die in eine jar-Datei verpackt ist, repräsentiert durch die Datei sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Ausführung der Java-Anwendung

Navigieren Sie in den Ordner target und starten Sie die Anwendung mit folgendem Befehl:

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

Beim Ausführen 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: Konnte Platzhalter 'sa.logic.api.url' im Wert "${sa.logic.api.url}" nicht auflösen.

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

▍Analyse der Java-Anwendung

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();
    }
}

Im SentimentController gibt es ein Feld saLogicApiUrl. Sein Wert wird durch die Eigenschaft festgelegt sa.logic.api.url.
Zeichenfolge saLogicApiUrl wird mit dem Wert /analyse/sentimentverkettet. Zusammen bilden sie die Adresse für den Aufruf des Mikrodienstes, der die Textanalyse durchführt.

▍Wertzuweisung der Eigenschaft

In Spring ist die Standardquelle für Eigenschaftenwerte die Datei application.properties, die Sie unter folgendem Pfad finden können sa-webapp/src/main/resources. Die Nutzung dieser Datei ist jedoch nicht der einzige Weg, um Eigenschaftenwerte festzulegen. Das kann auch mit einem Befehl der folgenden Art gemacht werden:

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 diese Konfiguration informieren wir die Spring-Webanwendung, wohin sie für Textanalysen Anfragen stellen soll.

Um uns das Leben zu erleichtern, entscheiden wir, dass die Python-Anwendung unter folgender Adresse erreichbar sein wird localhost:5000 und versuchen, dies nicht zu vergessen. Dadurch 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 wie erwartet funktionieren.

▍Einrichtung 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.

▍Abhängigkeiten installieren

Gehen Sie zum Projektordner sa-logic/sa und führen Sie die folgenden Befehle aus:

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

▍Anwendung starten

Nachdem die Abhängigkeiten installiert sind, sind wir bereit, die Anwendung zu starten:

python sentiment_analysis.py

Nach Ausführung dieses Befehls erhalten wir folgende Meldung:

* Running on http://0.0.0.0:5000/ (Drücken Sie CTRL+C, um zu beenden)

Das bedeutet, dass die Anwendung läuft und auf Anfragen unter der Adresse localhost:5000/

▍Code untersuchen

Lassen Sie uns den Code der Python-Anwendung betrachten, 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

Objektinitialisierung Flask.
Festlegung der Adresse für POST-Anfragen.
Eigenschaft extrahieren sentence aus dem Anfragekörper.
Anonyme Objektinitialisierung TextBlob und Abrufen des Wertes polarity für den ersten im Anfrage-Body eingegangenen Vorschlag (in unserem Fall handelt es sich um den einzigen Vorschlag, der zur Analyse übermittelt wird).
Antwort zurückgeben, in deren Body der Vorschlagstext und der dafür berechnete Wert enthalten sind. polarity.
Starten der Flask-Anwendung, die unter der Adresse erreichbar sein wird. 0.0.0.0:5000 (Sie können darauf auch mit einer Struktur wie dieser zugreifen. localhost:5000).

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

Alle Mikrodienste, aus denen die Anwendung besteht, sind in einen funktionsfähigen Zustand versetzt.

Bevor Sie fortfahren, öffnen Sie nun die React-Anwendung im Browser und versuchen Sie, mit ihrer Hilfe einen Vorschlag zu analysieren. Wenn alles richtig gemacht wurde – nach dem Drücken des Knopfes. Send werden Sie die Analyseergebnisse unter dem Textfeld sehen.

Im nächsten Abschnitt werden wir besprechen, wie wir unsere Mikrodienste in Docker-Containern ausführen. Dies ist notwendig, um die Anwendung für den Betrieb in einem Kubernetes-Cluster vorzubereiten.

Docker-Container

Kubernetes — ist ein System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen. Es wird auch als „Container-Orchestrator“ (container orchestrator) bezeichnet. Wenn Kubernetes mit Containern arbeitet, müssen wir uns, bevor wir dieses System nutzen, zunächst diese Container zulegen. Aber zuerst wollen wir über die Containers sprechen. Eine der besten Antworten auf die Frage, was das ist, finden wir in Dokumentation. Docker:

Ein Container-Image ist ein leichtgewichtiger, autonomer, ausführbarer Paket, das eine Anwendung enthält und alles Notwendige für ihren Start beinhaltet: den Anwendungscode, die Ausführungsumgebung, systemrelevante Tools und Bibliotheken sowie Konfigurationen. Containerisierte Anwendungen können sowohl in Linux- als auch in Windows-Umgebungen verwendet werden, wobei sie immer gleichmäßig unabhängig von der Infrastruktur funktionieren werden.

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

Um die besonderen Merkmale von Containern zu erkunden und diese mit anderen Anwendungsstartmethoden zu vergleichen, betrachten wir ein Beispiel für die Bereitstellung einer React-Anwendung sowohl mit einer virtuellen Maschine als auch mit einem Container.

▍Bereitstellung statischer Dateien einer React-Anwendung über virtuelle Maschinen

Bei dem Versuch, die Bereitstellung statischer Dateien über virtuelle Maschinen zu organisieren, stoßen wir auf folgende Nachteile:

Ineffiziente Ressourcennutzung, da jede virtuelle Maschine ein komplettes Betriebssystem darstellt.
Plattformabhängigkeit. Was auf einem bestimmten lokalen Computer funktioniert, könnte auf dem Produktionsserver völlig versagen.
Langsame und ressourcenintensive Skalierung einer auf virtuellen Maschinen basierenden Lösung.

Der Webserver Nginx, der statische Dateien bereitstellt, läuft auf einer virtuellen Maschine.

Wenn hingegen Container für eine ähnliche Aufgabe verwendet werden, lassen sich im Vergleich zu virtuellen Maschinen folgende Vorteile feststellen:

Effiziente Ressourcennutzung: Arbeiten mit einem Betriebssystem über Docker.
Plattformunabhängigkeit. Ein Container, den ein Entwickler auf seinem Computer starten kann, funktioniert überall.
Leichte Bereitstellung durch die Verwendung von Image-Schichten.

Ein Nginx-Webserver, der statische Dateien bedient und in einem Container läuft.

Wir haben virtuelle Maschinen und Container lediglich in einigen Punkten verglichen, aber selbst das reicht aus, um die Stärken von Containern zu spüren. Hier Hier finden Sie Details zu Docker-Containern.

▍Erstellung eines Container-Images für eine React-Anwendung

Der grundlegende Baustein eines Docker-Containers ist die Datei Dockerfile. Am Anfang dieser Datei wird das Basis-Image des Containers angegeben, danach folgen Anweisungen, die den Aufbau des Containers bestimmen, der den Anforderungen einer bestimmten Anwendung entspricht.

Bevor wir mit der Datei beginnen, Dockerfileerinnern wir uns daran, was wir getan haben, um die Dateien der React-Anwendung für die Bereitstellung auf dem Nginx-Server vorzubereiten:

Bau des React-Anwendungspakets (npm run build).
Starten des Nginx-Servers.
Kopieren des Inhalts des Verzeichnisses build aus dem Projektordner sa-frontend in den Serverordner nginx/html.

Unten sehen Sie die Parallelen zwischen der Erstellung eines Containers und den oben beschriebenen Aktionen, die auf einem lokalen Computer ausgeführt werden.

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

Die Anweisungen, die enthalten sein werden in Dockerfile der Anwendung SA-Frontend, bestehen aus lediglich zwei Befehlen. Tatsache ist, dass das Nginx-Entwicklungsteam ein Basis- Image für Nginx vorbereitet hat, das wir zur Erstellung unseres Images verwenden werden. Hier sind die beiden Schritte, die wir beschreiben müssen:

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

Wenn man von dieser Beschreibung zur Datei Dockerfileübergeht, wird sie so aussehen:

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

Wie Sie sehen, ist alles hier 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 vorhanden ist, nehmen und den Inhalt des Verzeichnisses build in das Verzeichnis nginx/html.

kopieren muss. Hier könnte sich eine Frage ergeben, warum ich weiß, wohin genau die Dateien aus dem Ordner buildkopiert werden müssen, oder besser gesagt — woher der Pfad stammt. /usr/share/nginx/htmlIn der Tat gibt es hier nichts Kompliziertes. Die entsprechenden Informationen finden Sie in Beschreibung der Abbildung.

▍Erstellung des Abbilds und Upload in das Repository

Bevor wir mit dem fertigen Abbild arbeiten können, müssen wir es in das Abbild-Repository hochladen. Hierfür nutzen wir die kostenlose Cloud-Plattform für das Hosting von Abbilden, Docker Hub. In diesem Stadium müssen Sie Folgendes tun:

Installieren Docker.
Sie müssen sich auf der Website von Docker Hub registrieren.
Melden Sie sich in Ihrem Konto an, indem Sie im Terminal den folgenden Befehl ausführen:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Jetzt müssen Sie mit dem Terminal in das Verzeichnis wechseln sa-frontend und dort den 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 dieser Befehl verkürzt werden, indem Sie -f Dockerfileaus dem Befehl entfernen, da sich diese Datei bereits im Ordner befindet, in dem wir diesen Befehl ausführen.

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

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Nach Abschluss überprüfen Sie die Liste Ihrer Repositorys auf Docker Hub, um herauszufinden, ob das Hochladen des Images in den Cloud-Speicher erfolgreich war.

▍Container starten

Jetzt kann jeder das Image herunterladen und ausführen, bekannt als $DOCKER_USER_ID/sentiment-analysis-frontend. Um dies zu tun, führen Sie bitte die folgende Befehlsfolge aus:

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

Jetzt ist der Container gestartet und wir können mit der Erstellung anderer benötigter Images fortfahren. Aber bevor wir weitermachen, lassen Sie uns die Struktur 80:80, die im Image-Startbefehl auftaucht und möglicherweise unklar erscheint, näher betrachten.

Die erste Zahl 80 ist die Portnummer des Hosts (also des lokalen Computers).
Die zweite Zahl 80 ist der Containerport, auf den die Anfrage umgeleitet werden soll.

Betrachten wir die folgende Abbildung.

Portweiterleitung

Das System leitet Anfragen vom Port <hostPort> an den Port <containerPort>. Das bedeutet, dass der Zugriff auf den Port 80 des Computers auf den Port 80 des Containers umgeleitet wird.

Da der Port 80 wenn es auf einem lokalen Computer geöffnet ist, können Sie über die Adresse auf die Anwendung von diesem Computer aus zugreifen localhost:80. Sollte Ihr System jedoch Docker nicht unterstützen, können Sie die Anwendung auf einer Docker-VM starten, deren Adresse wie folgt aussieht :80. Um die IP-Adresse der Docker-VM herauszufinden, können Sie den Befehl docker-machine ip.

verwenden. An diesem Punkt, nach dem erfolgreichen Starten des Containers der Frontend-Anwendung, sollten Sie in der Lage sein, die Seite im Browser zu öffnen.

▍Die .dockerignore-Datei

Wenn wir das Abbild der Anwendung erstellen SA-Frontend, könnten wir feststellen, dass dieser Prozess äußerst langsam ist. Das geschieht, weil dem Docker-Dämon der Build-Kontext des Abbilds gesendet werden muss. Das Verzeichnis, das den Build-Kontext darstellt, wird als letztes Argument des Befehls angegeben docker build. In unserem Fall steht am Ende dieses Befehls ein Punkt. Das führt dazu, dass die folgende Struktur in den Build-Kontext einbezogen wird:

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

Aber von all diesen vorhandenen Ordnern benötigen wir nur den Ordner build. Das Hochladen anderer Dateien ist eine reine Zeitverschwendung. Der Build-Prozess kann beschleunigt werden, indem Sie Docker anweisen, welche Verzeichnisse ignoriert werden sollen. Genau dafür benötigen wir die Datei .dockerignore. Wenn Sie mit der Datei vertraut sind, wird Ihnen die Struktur dieser Datei sicher bekannt vorkommen. Sie listet die Verzeichnisse auf, die das Image-Builder-System ignorieren kann. In unserem Fall sieht der Inhalt dieser Datei folgendermaßen aus: .gitignorenode_modules src public

muss sich im selben Ordner wie die Datei befinden

Die Datei .dockerignore . Jetzt dauert der Build des Images nur noch wenige Sekunden. DockerfileJetzt befassen wir uns mit dem Image für die Java-Anwendung.

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

Wissen Sie, Sie haben bereits alles Wesentliche zum Erstellen von Container-Images gelernt. Deshalb wird dieser Abschnitt recht kurz sein.

Öffnen Sie die Datei

, die sich im Projektordner befindet Dockerfile. Wenn Sie den Text dieser Datei lesen, werden Sie auf nur zwei neue Konstruktionen stoßen, die mit den Schlüsselwörtern beginnen sa-webappENV SA_LOGIC_API_URL http://localhost:5000 … EXPOSE 8080 ENV und EXPOSE:

Das Schlüsselwort

Schlüsselwort ENV ermöglicht die Deklaration von Umgebungsvariablen innerhalb von Docker-Containern. In unserem Fall ermöglicht es insbesondere die Festlegung einer URL für den Zugriff auf die API der Anwendung, die Textanalysen durchführt.

Schlüsselwort EXPOSE weist Docker an, dass dieser Port geöffnet werden muss. Wir werden während der Arbeit mit der Anwendung diesen Port nutzen. Dabei ist zu beachten, dass in Dockerfile der Anwendung SA-Frontend diesem Befehl kein Bezug besteht. Dies dient lediglich Dokumentationszwecken; mit anderen Worten, diese Konstruktion ist für diejenigen gedacht, die später die Dockerfile.

Abbildung des Images und dessen Übertragung in das Repository erfolgt genau wie im vorherigen Beispiel. Falls Sie sich jedoch noch unsicher fühlen, können Sie die entsprechenden Befehle in der Datei README.md im Ordner sa-webapp.

▍Abbildung 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 finden. Die Befehle zum Erstellen des Images und zum Übertragen in das Repository sollten Ihnen ebenfalls bekannt sein, können jedoch, wie bei unseren anderen Anwendungen, in der Datei gefunden werden 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 ausprobieren.

Lassen Sie uns die Anwendungsversion starten sa-logic und sie zum Lauschen auf den Port einrichten 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Lassen Sie uns die Anwendungsversion starten sa-webapp und sie zum Lauschen auf den Port einrichten 8080. Außerdem müssen wir den Port einstellen, an dem die Python-Anwendung auf Anfragen von der Java-Anwendung wartet, indem wir die Umgebungsvariable 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 man die IP-Adresse des Containers oder der Docker-VM ermittelt, sehen Sie in die Datei README.

Lassen Sie uns die Anwendungsversion starten sa-frontend:

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

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

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

So sieht das Schema unserer Anwendung jetzt aus.

Mikroservices werden in Containern ausgeführt.

Fazit: Warum benötigen wir ein Kubernetes-Cluster?

Gerade haben wir die Dateien untersucht Dockerfile, darüber gesprochen, wie man Images erstellt und sie in ein Docker-Repository hochlädt. Zudem haben wir gelernt, wie man den Build-Prozess der Images beschleunigt, indem wir die Datei nutzen .dockerignore. Dadurch werden unsere Mikrodienste jetzt in Docker-Containern ausgeführt. An dieser Stelle könnte Ihnen die berechtigte Frage einfallen, warum wir Kubernetes brauchen. Die Antwort auf diese Frage wird Teil zwei dieses Materials ausmachen. Denken Sie für den Moment über Folgendes nach:
Angenommen, unsere Webanwendung zur Textanalyse wird weltberühmt. Jede Minute kommen Millionen von Anfragen. Das bedeutet, dass die Mikrodienste sa-webapp und sa-logic unter enormer Last stehen werden. Wie skalieren wir die Container, in denen die Mikrodienste laufen?

Quelle: habr.com