👶🏻 ⭕️ 🐫 Kubernetes-Handbuch, Teil 1: Anwendungen, Microservices und Container ‼️ 👨‍👧 👨🏾‍⚕️

Auf unsere Bitte hin hat Habr den Kubernetes- Hub erstellt und wir freuen uns, die erste Veröffentlichung darin zu veröffentlichen. Abonnieren!

Kubernetes ist einfach. Warum zahlen mir Banken viel Geld für die Arbeit in diesem Bereich, während jeder diese Technologie in nur wenigen Stunden beherrschen kann?

Wenn Sie Zweifel haben, dass Kubernetes so schnell erlernt werden kann, empfehle ich Ihnen, es selbst zu versuchen. Nachdem Sie dieses Material beherrschen, können Sie die Anwendung basierend auf Microservices im Kubernetes-Cluster ausführen. Ich kann dies garantieren, da ich Kubernetes gerade durch die hier verwendete Methodik für die Arbeit mit unseren Kunden schule. Was unterscheidet dieses Handbuch von anderen? In der Tat - viele Dinge. Die meisten dieser Materialien beginnen also mit einer Erklärung einfacher Dinge - Konzepte von Kubernetes und Funktionen des kubectl-Teams. Die Autoren dieser Materialien glauben, dass ihr Leser mit Anwendungsentwicklung, Microservices und Docker-Containern vertraut ist. Wir werden den anderen Weg gehen. Lassen Sie uns zunächst darüber sprechen, wie eine Anwendung basierend auf Microservices auf einem Computer ausgeführt wird. Betrachten Sie dann die Zusammenstellung von Containerbildern für jeden Mikrodienst. Danach lernen wir Kubernetes kennen und analysieren die Bereitstellung einer Microservice-basierten Anwendung in einem von Kubernetes verwalteten Cluster.

Ein solcher Ansatz mit einer schrittweisen Herangehensweise an Kubernetes vermittelt die Tiefe des Verständnisses, das einem gewöhnlichen Menschen widerfährt, um zu verstehen, wie einfach alles in Kubernetes angeordnet ist. Kubernetes ist natürlich eine einfache Technologie, vorausgesetzt, jeder, der sie lernen möchte, weiß, wo und wie sie verwendet wird.

Lassen Sie uns nun ohne weiteres an die Arbeit gehen und über die Anwendung sprechen, mit der wir arbeiten werden.

Experimentelle Anwendung

Unsere Anwendung wird nur eine Funktion ausführen. Es akzeptiert als Eingabe einen Satz und führt dann unter Verwendung der Textanalyse eine Stimmungsanalyse dieses Satzes durch, wobei eine Schätzung der emotionalen Einstellung des Verfassers des Satzes zu einem bestimmten Objekt erhalten wird.

So sieht das Hauptfenster dieser Anwendung aus.

Webanwendung zur Analyse der Textstimmung

Aus technischer Sicht besteht die Anwendung aus drei Mikrodiensten, von denen jeder eine bestimmte Reihe von Aufgaben löst:

SA-Frontend ist ein Nginx-Webserver, der statische React-Dateien bereitstellt.
SA-WebApp ist eine Java-basierte Webanwendung, die Anforderungen vom Front-End verarbeitet.
SA-Logic ist eine Python-Anwendung, die eine Analyse der Textstimmung durchführt.

Es ist wichtig zu beachten, dass Microservices nicht isoliert existieren. Sie setzen die Idee der "Aufgabentrennung" um, müssen jedoch miteinander interagieren.

Anwendungsdatenströme

In der obigen Abbildung sehen Sie die nummerierten Stufen des Systems und veranschaulichen die Datenflüsse in der Anwendung. Analysieren wir sie:

Der Browser fordert die Datei index.html vom Server an (der seinerseits das React-Anwendungspaket herunterlädt).
Der Benutzer interagiert mit der Anwendung. Dadurch wird eine auf Spring basierende Webanwendung aufgerufen.
Die Webanwendung leitet die Anforderung zur Textanalyse an die Python-Anwendung weiter.
Die Python-Anwendung analysiert die Tonalität des Textes und gibt das Ergebnis als Antwort auf die Anforderung zurück.
Die Spring-Anwendung sendet eine Antwort an die React-Anwendung (und zeigt dem Benutzer wiederum das Ergebnis der Textanalyse an).

Den Code für alle diese Anwendungen finden Sie hier . Ich empfehle Ihnen, dieses Repository jetzt in sich selbst zu kopieren, da noch viele interessante Experimente damit vor uns liegen.

Starten einer Microservice-basierten Anwendung auf einem lokalen Computer

Damit die Anwendung funktioniert, müssen alle drei Microservices ausgeführt werden. Beginnen wir mit dem süßesten von ihnen - mit der Front-End-Anwendung.

▍Konfigurieren Reagieren Sie auf die lokale Entwicklung

Um die React-Anwendung ausführen zu können, müssen Sie die Plattformen Node.js und NPM auf Ihrem Computer installieren. Nachdem Sie dies alles installiert haben, gehen Sie über das Terminal zum sa-frontend Projektordner und führen Sie den folgenden Befehl aus:

 npm install

Dank der Ausführung dieses Befehls werden Abhängigkeiten der React-Anwendung, deren Einträge sich in der Datei package.json befinden, in den Ordner node_modules geladen. Führen Sie den folgenden Befehl aus, nachdem die Abhängigkeiten in denselben Ordner heruntergeladen wurden:

 npm start

Das ist alles. Jetzt wird die React-Anwendung ausgeführt. Der Zugriff darauf kann über die Adresse localhost:3000 im Browser erfolgen. Sie können etwas in seinem Code ändern. Sie werden die Auswirkungen dieser Änderungen sofort im Browser sehen. Dies ist möglich durch den sogenannten "heißen" Austausch von Modulen. Dank dessen wird die Front-End-Entwicklung zu einer einfachen und unterhaltsamen Aufgabe.

▍Vorbereitung einer React-Anwendung für die Ausgabe an die Produktion

Für die tatsächliche Verwendung der React-Anwendung müssen wir sie in eine Reihe statischer Dateien konvertieren und sie über einen Webserver an Clients weitergeben.

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

 npm run build

Dadurch wird ein build Verzeichnis im Projektordner erstellt. Es enthält alle statischen Dateien, die für die Funktion der React-Anwendung erforderlich sind.

▍Servieren statischer Dateien mit Nginx-Tools

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

Bei diesem Ansatz ist die beim Erstellen der React-Anwendung generierte Datei index.html [your_nginx_installation_dir]/html/index.html . Dies ist die Datei, die der Nginx-Server standardmäßig beim Zugriff ausgibt. Der Server ist so konfiguriert, dass er Port 80 [your_nginx_installation_dir]/conf/nginx.conf . Sie können ihn jedoch nach Bedarf konfigurieren, indem Sie die Datei [your_nginx_installation_dir]/conf/nginx.conf .

Öffnen Sie nun Ihren Browser und gehen Sie zu localhost:80 . Sie sehen die Seite Anwendung reagieren.

Von Nginx Server bereitgestellte Anwendung reagieren

Wenn Sie jetzt etwas in das Feld Type your sentence eingeben eingeben und auf die Schaltfläche Send klicken, geschieht nichts. Wenn Sie sich jedoch die Konsole ansehen, werden dort Fehlermeldungen angezeigt. Um genau zu verstehen, wo diese Fehler auftreten, analysieren wir den Anwendungscode.

▍Analyse des Front-End-Anwendungscodes

App.js wir uns den Code der Datei App.js , können wir sehen, dass durch Klicken auf die Schaltfläche Send die Methode analyzeSentence() wird. Der Code für diese Methode ist unten angegeben. Beachten Sie gleichzeitig, dass für jede Zeile, für die ein Kommentar des Formulars # vorhanden ist, eine Erklärung unter dem Code angegeben wird. Auf die gleiche Weise werden wir andere Codeteile 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. URL, unter der die POST-Anforderung ausgeführt wird. Es versteht sich, dass diese Adresse eine Anwendung enthält, die auf solche Anforderungen wartet.

2. Der an die Anwendung gesendete Anfragetext. Hier ist ein Beispiel für einen Anfragetext:

 {   sentence: "I like yogobella!" }

3. Nach Erhalt einer Antwort auf die Anforderung wird der Status der Komponente aktualisiert. Dadurch wird die Komponente erneut gerendert. Wenn wir Daten empfangen (dh ein JSON-Objekt, das die eingegebenen Daten und die berechnete Textbewertung enthält), geben wir die Polarity , da die entsprechenden Bedingungen erfüllt sind. So beschreiben wir die Komponente:

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

Der Code scheint ziemlich gut zu funktionieren. Was ist hier denn falsch? Wenn Sie davon ausgehen, dass an der Adresse, an die die Anwendung versucht, eine POST-Anfrage zu senden, bis jetzt nichts diese Anfrage annehmen und verarbeiten kann, haben Sie absolut Recht. Um Anforderungen zu verarbeiten, die an der Adresse http://localhost:8080/sentiment ankommen, müssen wir eine Webanwendung ausführen, die auf Spring basiert.

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

▍Richten Sie eine Spring-basierte Webanwendung ein

Zum Bereitstellen der Spring-Anwendung benötigen Sie JDK8 und Maven sowie ordnungsgemäß konfigurierte Umgebungsvariablen. Nachdem Sie dies alles installiert haben, können Sie weiter an unserem Projekt arbeiten.

▍Verpacken der Anwendung in eine JAR-Datei

Gehen Sie mit dem Terminal zum Ordner sa-webapp und geben Sie den folgenden Befehl ein:

 mvn install

Nach Ausführung dieses Befehls wird das target im Ordner sa-webapp . Es wird eine Java-Anwendung in einer JAR-Datei enthalten sein, die durch sentiment-analysis-web-0.0.1-SNAPSHOT.jar .

▍Starten Sie die Java-Anwendung

Gehen Sie zum Zielordner und starten Sie die Anwendung mit dem folgenden Befehl:

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

Während der Ausführung dieses Befehls tritt ein Fehler auf. Um das Problem zu beheben, können wir die Ausnahmeinformationen in den Stack-Trace-Daten analysieren:

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

Das Wichtigste für uns ist hier die Erwähnung der Unmöglichkeit, die Bedeutung von sa.logic.api.url . Analysieren wir den Code, in dem der Fehler auftritt.

▍ Analyse des Java-Anwendungscodes

Hier ist das Code-Snippet, 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();   } }

S entimentController verfügt über ein saLogicApiUrl Feld. Sein Wert wird durch die Eigenschaft sa.logic.api.url .
Die Zeichenfolge saLogicApiUrl mit dem Wert /analyse/sentiment verkettet. Zusammen bilden sie eine Adresse für den Zugriff auf einen Mikrodienst, der eine Textanalyse durchführt.

▍Stellen Sie den Eigenschaftswert ein

Im Frühjahr ist die Standardquelle für Eigenschaftswerte die Datei application.properties , die sich unter sa-webapp/src/main/resources . Die Verwendung ist jedoch nicht die einzige Möglichkeit, Eigenschaftswerte festzulegen. Sie können dies mit einem Befehl wie dem folgenden 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 Spring-Webanwendung mit, wohin sie zum Ausführen von Textanalyseanforderungen gehen muss.

Um unser Leben nicht zu verkomplizieren, entscheiden wir, dass die Python-Anwendung bei localhost:5000 verfügbar sein wird, und versuchen, sie nicht zu vergessen. Infolgedessen sieht der Befehl zum Starten der Spring-Anwendung folgendermaßen aus:

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

Unserem System fehlt eine Python-Anwendung

Jetzt müssen wir nur noch die Python-Anwendung starten und das System funktioniert wie erwartet.

▍Konfigurieren einer Python-Anwendung

Um eine Python-Anwendung ausführen zu können, müssen Python 3 und Pip installiert sein und Sie müssen die entsprechenden Umgebungsvariablen korrekt festlegen.

▍Installation von Abhängigkeiten

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

▍Starten Sie die Anwendung

Nach der Installation der Abhängigkeiten können wir die Anwendung starten:

 python sentiment_analysis.py

Nach Ausführung dieses Befehls werden wir über Folgendes informiert:

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

Dies bedeutet, dass die Anwendung ausgeführt wird und auf Anfragen bei localhost:5000/ wartet localhost:5000/

▍ Code-Forschung

Betrachten Sie den Python-Anwendungscode, um zu verstehen, wie er auf Anforderungen 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

Initialisieren eines Flask .
Festlegen der Adresse zum Ausführen von POST-Anforderungen.
Abrufen der Satzeigenschaft aus dem Anforderungshauptteil.
Initialisieren des anonymen TextBlob Objekts und TextBlob des polarity für den ersten Satz im Anforderungshauptteil (in unserem Fall ist dies der einzige Satz, der zur Analyse übergeben wird).
Die Rückgabe der Antwort, in deren Hauptteil der Text des Vorschlags und der dafür berechnete polarity enthalten sind.
Starten der Flask-Anwendung, die unter der Adresse 0.0.0.0:5000 verfügbar 0.0.0.0:5000 (Sie können auch mit einem Design des Formulars localhost:5000 zugreifen).

Jetzt werden die Microservices ausgeführt, aus denen die Anwendung besteht. Sie sind so konfiguriert, dass sie miteinander interagieren. So sieht das Anwendungsdiagramm in dieser Arbeitsphase aus.

Alle Microservices, aus denen sich die Anwendung zusammensetzt, werden in einen gesunden Zustand versetzt.

Bevor Sie fortfahren, öffnen Sie jetzt die React-Anwendung in einem Browser und versuchen Sie, einen Vorschlag damit zu analysieren. Wenn alles richtig gemacht wurde, sehen Sie nach dem Klicken auf die Schaltfläche Send die Analyseergebnisse unter dem Textfeld.

Im nächsten Abschnitt werden wir darüber sprechen, wie unsere Microservices in Docker-Containern ausgeführt werden. Dies ist erforderlich, um die Anwendung für den Start im Kubernetes-Cluster vorzubereiten.

Docker-Container

Kubernetes ist ein System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von Anwendungen in Containern. Es wird auch als "Container Orchestrator" bezeichnet. Wenn Kubernetes mit Containern arbeitet, müssen wir diese Container zuerst erwerben, bevor wir dieses System verwenden können. Aber zuerst sprechen wir darüber, was Container sind. Die vielleicht beste Antwort auf die Frage, was es ist, finden Sie in der Dokumentation zu Docker:

Ein Container-Image ist ein leichtes, eigenständiges, ausführbares Paket, das eine Art Anwendung enthält, die alles enthält, was Sie zum Ausführen benötigen: Anwendungscode, Laufzeit, Systemtools und Bibliotheken, Einstellungen. Containerisierte Programme können in Linux- und Windows-Umgebungen verwendet werden und funktionieren unabhängig von der Infrastruktur immer gleich.

Dies bedeutet, dass Container auf jedem Computer ausgeführt werden können, einschließlich Produktionsservern, und in jeder Umgebung funktionieren die darin enthaltenen Anwendungen auf die gleiche Weise.

Betrachten Sie ein Beispiel für die Bereitstellung einer React-Anwendung mithilfe einer virtuellen Maschine und eines Containers, um die Funktionen von Containern zu untersuchen und sie mit anderen Methoden zum Starten von Anwendungen zu vergleichen.

▍Serving Reaktive statische Anwendungsdateien mithilfe einer virtuellen Maschine

Beim Versuch, die Wartung statischer Dateien mithilfe virtueller Maschinen zu organisieren, treten folgende Nachteile auf:

Ineffiziente Ressourcennutzung, da jede virtuelle Maschine ein vollwertiges Betriebssystem ist.
Plattformabhängig. Was auf einem bestimmten lokalen Computer funktioniert, funktioniert möglicherweise nicht auf einem Produktionsserver.
Langsame und ressourcenintensive Skalierung einer Lösung auf der Basis einer virtuellen Maschine.

Nginx Static Server Webserver, der auf einer virtuellen Maschine ausgeführt wird

Wenn Container verwendet werden, um ein ähnliches Problem zu lösen, können im Vergleich zu virtuellen Maschinen die folgenden Stärken festgestellt werden:

Effiziente Ressourcennutzung: Arbeiten mit dem Betriebssystem mithilfe von Docker.
Plattformunabhängigkeit. Ein Container, den ein Entwickler auf seinem Computer ausführen kann, funktioniert überall.
Leichte Bereitstellung durch Verwendung von Bildebenen.

Nginx Static Server Webserver, der in einem Container ausgeführt wird

Wir haben virtuelle Maschinen und Container nur in wenigen Punkten verglichen, aber selbst dies reicht aus, um die Stärken der Container zu spüren. Weitere Informationen zu Docker-Containern finden Sie hier.

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

Der Hauptbaustein des Docker-Containers ist die Docker- Dockerfile . Machen Sie am Anfang dieser Datei eine Aufzeichnung des Grundabbilds des Containers, und enthalten Sie dann eine Folge von Anweisungen, die die Reihenfolge angeben, in der der Container erstellt wird, um die Anforderungen einer bestimmten Anwendung zu erfüllen.

Bevor wir mit der Dockerfile Datei arbeiten, erinnern wir uns daran, was wir getan haben, um die React-Anwendungsdateien für den Upload auf den Nginx-Server vorzubereiten:

Erstellen Sie ein React-Anwendungspaket ( npm run build ).
Nginx-Server starten.
Kopieren Sie den Inhalt des build Verzeichnisses aus dem Projektordner sa-frontend in den nginx/html .

Unten sehen Sie die Parallelen zwischen dem Erstellen des Containers und den oben auf dem lokalen Computer ausgeführten Aktionen.

▍Erstellen einer Docker-Datei für SA-Frontend

Die Anweisungen, die in der Dockerfile für die SA-Frontend Anwendung enthalten sein werden, bestehen nur aus zwei Befehlen. Tatsache ist, dass das Nginx-Entwicklungsteam ein Basis- Image für Nginx erstellt hat, mit dem wir unser Image erstellen werden. Hier sind die zwei Schritte, die wir beschreiben müssen:

Die Basis des Bildes benötigen Sie, um das Bild von Nginx zu erstellen.
Der Inhalt des Ordners sa-frontend/build muss in den nginx/html kopiert werden.

Wenn wir von dieser Beschreibung zur Dockerfile , Dockerfile sie folgendermaßen aus:

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

Wie Sie sehen können, ist hier alles sehr einfach, während sich der Inhalt der Datei sogar als gut lesbar und verständlich herausstellt. Diese Datei weist das System an, das nginx Image mit allem, was bereits vorhanden ist, aufzunehmen und den Inhalt des build Verzeichnisses in das Verzeichnis nginx/html kopieren.

Hier haben Sie möglicherweise eine Frage dazu, woher ich weiß, wo genau ich Dateien aus dem build Ordner kopieren muss build dh woher der Pfad /usr/share/nginx/html stammt. In der Tat, und es gibt nichts Kompliziertes. Tatsache ist, dass die relevanten Informationen in der Beschreibung des Bildes zu finden sind.

▍Erstellen eines Bildes und Hochladen in das Repository

Bevor wir mit dem fertigen Image arbeiten können, müssen wir es an das Image-Repository senden. Zu diesem Zweck verwenden wir die kostenlose Cloud-Plattform zum Hosten von Docker Hub-Images. In dieser Phase der Arbeit müssen Sie Folgendes tun:

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

Jetzt müssen Sie das Terminal verwenden, um zum sa-frontend Verzeichnis zu sa-frontend und dort den folgenden Befehl auszuführen:

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

Im Folgenden muss in ähnlichen Befehlen $DOCKER_USER_ID auf dem Docker Hub durch Ihren Benutzernamen ersetzt werden. Zum Beispiel könnte dieser Teil des Befehls folgendermaßen aussehen: rinormaloku/sentiment-analysis-frontend .

Gleichzeitig kann dieser Befehl durch Entfernen von -f Dockerfile verkürzt werden, da diese Datei bereits in dem Ordner vorhanden ist, in dem wir diesen Befehl ausführen.

Um das fertige Image an das Repository zu senden, benötigen wir den folgenden Befehl:

 docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Überprüfen Sie nach der Ausführung die Liste Ihrer Repositorys im Docker Hub, um festzustellen, ob das Image erfolgreich an die Cloud gesendet wurde.

▍Startcontainer

Jetzt kann jeder ein Bild herunterladen und ausführen, das als $DOCKER_USER_ID/sentiment-analysis-frontend . Dazu 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 wird der Container gestartet und wir können weiterarbeiten und die anderen benötigten Bilder erstellen. Bevor wir fortfahren, 80:80 wir 80:80 Konstrukt an, das sich im Image- 80:80 befindet und möglicherweise unverständlich erscheint.

Die erste Nummer 80 ist die Host-Port-Nummer (dh der lokale Computer).
Die zweite Nummer 80 ist der Port des Containers, an den die Anforderung umgeleitet werden soll.

Betrachten Sie die folgende Abbildung.

Portweiterleitung

Das System leitet Anforderungen vom <hostPort> an den <containerPort> <hostPort> . Das heißt, der Zugriff auf Port 80 Computers wird auf Port 80 Containers umgeleitet.

Da Port 80 auf dem lokalen Computer geöffnet 80 , können Sie von diesem Computer aus auf localhost:80 auf die Anwendung zugreifen. Wenn Ihr System Docker nicht unterstützt, können Sie die Anwendung auf der virtuellen <docker-machine ip>:80 ausführen, deren Adresse wie folgt aussieht: <docker-machine ip>:80 . Um die IP-Adresse der virtuellen docker-machine ip herauszufinden, können Sie den docker-machine ip .

Zu diesem Zeitpunkt sollten Sie nach dem erfolgreichen Start des Frontend-Anwendungscontainers in der Lage sein, seine Seite in einem Browser zu öffnen.

▍ .dockerignore-Datei

Beim Sammeln des Images der SA-Frontend Anwendung konnten wir feststellen, dass dieser Prozess extrem langsam ist. Dies geschieht aufgrund der Tatsache, dass der Build-Kontext des Images an den Docker-Daemon gesendet werden muss. Das Verzeichnis, das den Build-Kontext darstellt, wird durch das letzte Argument des docker build . In unserem Fall steht am Ende dieses Befehls ein Punkt. Dies führt dazu, dass die folgende Struktur in den Assemblykontext aufgenommen wird:

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

Von allen hier vorhandenen Ordnern benötigen wir jedoch nur den build Ordner. Alles andere herunterzuladen ist Zeitverschwendung. Builds können beschleunigt werden, indem Docker mitgeteilt wird, welche Verzeichnisse ignoriert werden sollen. Dazu benötigen wir eine .dockerignore Datei. Wenn Sie mit der .gitignore Datei vertraut sind, wird .gitignore die Struktur dieser Datei sicherlich bekannt vorkommen. Es werden Verzeichnisse aufgelistet, die das Image-Assembly-System möglicherweise ignoriert. In unserem Fall sieht der Inhalt dieser Datei folgendermaßen aus:

 node_modules src public

Die .dockerignore Datei muss sich im selben Ordner wie die Dockerfile Datei Dockerfile . Das Zusammenstellen des Bildes dauert nun einige Sekunden.

Schauen wir uns nun die Java-Anwendung an.

▍ Java-

, . .

Dockerfile , sa-webapp . , , ENV EXPOSE :

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

ENV Docker. , URL API , .

EXPOSE Docker , . . , Dockerfile SA-Frontend . , , , Dockerfile .

, . — README.md sa-webapp .

▍ Python-

Dockerfile sa-logic , . , , , README.md sa-logic .

▍

- , ? . .

sa-logic 5050 :

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

sa-webapp 8080 . , , Python- Java-, SA_LOGIC_API_URL :

 $ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app

, IP- Docker — README .

sa-frontend :

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

, localhost:80 .

, sa-webapp , Docker, App.js sa-frontend , IP- analyzeSentence() , . .

.

: Kubernetes?

Dockerfile , , Docker. , , .dockerignore . Docker. , Kubernetes. . :
, - . . , sa-webapp sa-logic . , ?

Kubernetes-Handbuch, Teil 1: Anwendungen, Microservices und Container