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

Auf unseren Wunsch hin hat Habr einen Hub geschaffen Kubernetes und wir freuen uns, die erste Veröffentlichung darin platzieren zu können. 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 bezweifeln, dass Kubernetes so schnell erlernt werden kann, empfehle ich Ihnen, es selbst zu versuchen. Wenn Sie dieses Material beherrschen, können Sie nämlich eine auf Microservices basierende Anwendung in einem Kubernetes-Cluster ausführen. Das kann ich garantieren, denn mit der gleichen Methodik, die ich hier anwende, bringe ich unseren Kunden bei, wie man mit Kubernetes arbeitet. Was unterscheidet diesen Leitfaden von anderen? Eigentlich viele Dinge. Daher beginnen die meisten dieser Materialien mit einer Erklärung einfacher Dinge – der Konzepte von Kubernetes und der Funktionen des Befehls kubectl. Die Autoren dieser Artikel gehen davon aus, dass ihr Leser mit Anwendungsentwicklung, Microservices und Docker-Containern vertraut ist. Wir gehen in die andere Richtung. Lassen Sie uns zunächst darüber sprechen, wie Sie eine auf Microservices basierende Anwendung auf einem Computer ausführen. Dann schauen wir uns die Erstellung von Container-Images für jeden Microservice an. Anschließend machen wir uns mit Kubernetes vertraut und analysieren die Bereitstellung einer auf Microservices basierenden Anwendung in einem von Kubernetes verwalteten Cluster.

Dieser Ansatz mit einer schrittweisen Annäherung an Kubernetes wird das tiefe Verständnis dessen vermitteln, was passiert, das der Durchschnittsmensch benötigt, um zu verstehen, wie einfach alles in Kubernetes angeordnet ist. Kubernetes ist sicherlich eine einfache Technologie, vorausgesetzt, wer sie beherrschen will, weiß, wo und wie sie eingesetzt wird.

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

Experimentelle App

Unsere Anwendung führt nur eine Funktion aus. Es nimmt als Eingabe einen Satz und führt anschließend mithilfe von Textanalysetools eine Sentimentanalyse dieses Satzes durch, um eine Einschätzung der emotionalen Einstellung des Autors des Satzes zu einem bestimmten Objekt zu erhalten.

So sieht das Hauptfenster dieser Anwendung aus.

Webanwendung zur Stimmungsanalyse

Aus technischer Sicht besteht die Anwendung aus drei Microservices, die jeweils eine bestimmte Reihe von Aufgaben lösen:

SA-Frontend ist ein Nginx-Webserver, der statische React-Dateien bereitstellt.
SA-WebApp ist eine in Java geschriebene Webanwendung, die Anfragen vom Frontend verarbeitet.
SA-Logic ist eine Python-Anwendung, die eine Text-Sentiment-Analyse durchführt.

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

Datenflüsse in der Anwendung

Im obigen Diagramm sehen Sie die nummerierten Stufen des Systems, die den Datenfluss in der Anwendung veranschaulichen. Lassen Sie uns sie aufschlüsseln:

Der Browser fordert eine Datei vom Server an index.html (was wiederum das React-App-Paket lädt).
Der Benutzer interagiert mit der Anwendung, dies führt zu einem Aufruf einer auf Spring basierenden Webanwendung.
Die Webanwendung leitet die Anforderung zum Parsen des Textes an die Python-Anwendung weiter.
Die Python-Anwendung analysiert die Stimmung des Textes und gibt das Ergebnis als Antwort auf die Anfrage zurück.
Die Spring-Anwendung sendet eine Antwort an die React-Anwendung (die wiederum dem Benutzer das Ergebnis des analysierten Texts anzeigt).

Der Code für alle diese Anwendungen kann gefunden werden hier. Ich empfehle Ihnen, dieses Repository jetzt auf sich selbst zu kopieren, da noch viele interessante Experimente damit vor uns liegen.

Ausführen einer auf Microservices basierenden Anwendung auf dem lokalen Computer

Damit die Anwendung funktioniert, müssen wir alle drei Microservices starten. Beginnen wir mit der schönsten davon – der Front-End-Anwendung.

▍Einrichten von React für die lokale Entwicklung

Um eine React-Anwendung auszuführen, müssen Sie das Node.js-Framework und NPM auf Ihrem Computer installieren. Nachdem Sie dies alles installiert haben, gehen Sie über das Terminal zum Projektordner sa-frontend und führen Sie den folgenden Befehl aus:

npm install

Durch Ausführen dieses Befehls im Ordner node_modules Die Abhängigkeiten der React-Anwendung werden geladen, deren Datensätze in der Datei enthalten sind package.json. Führen Sie nach dem Herunterladen der Abhängigkeiten im selben Ordner den folgenden Befehl aus:

npm start

Das ist alles. Die React-App wird jetzt ausgeführt und kann durch Navigieren zur Browseradresse aufgerufen werden localhost:3000. Sie können etwas an seinem Code ändern. Sie werden die Auswirkung dieser Änderungen sofort im Browser sehen. Möglich ist dies durch den sogenannten „Hot“-Austausch von Modulen. Dadurch wird die Frontend-Entwicklung zu einem einfachen und angenehmen Erlebnis.

▍Vorbereiten einer React-App für die Produktion

Um eine React-App tatsächlich verwenden zu können, müssen wir sie in eine Reihe statischer Dateien konvertieren und diese über einen Webserver an Clients bereitstellen.

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

npm run build

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

▍Bereitstellung statischer Dateien mit Nginx

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

Bei diesem Ansatz wird die Datei während der Assemblierung der React-Anwendung generiert index.html wird verfügbar sein unter [your_nginx_installation_dir]/html/index.html. Dies ist die Datei, die der Nginx-Server standardmäßig ausgibt, wenn er darauf zugreift. Der Server ist so konfiguriert, dass er einen Port überwacht 80, aber Sie können es nach Ihren Wünschen anpassen, indem Sie die Datei bearbeiten [your_nginx_installation_dir]/conf/nginx.conf.

Öffnen Sie nun Ihren Browser und gehen Sie zu localhost:80. Sie sehen die Seite der React-App.

Vom Nginx-Server bereitgestellte React-App

Wenn Sie nun etwas in das Feld eingeben Type your sentence und drücken Sie die Taste Send - Nichts wird passieren. Wenn Sie jedoch auf die Konsole schauen, können Sie dort Fehlermeldungen sehen. Um genau zu verstehen, wo diese Fehler auftreten, analysieren wir den Anwendungscode.

▍Analyse des Codes der Front-End-Anwendung

Schauen Sie sich den Code der Datei an App.js, wir können das sehen, wenn wir auf die Schaltfläche klicken Send ruft eine Methode auf analyzeSentence(). Der Code für diese Methode ist unten dargestellt. Achten Sie dabei darauf, dass für jede Zeile, zu der es einen Kommentar des Formulars gibt, vorhanden ist # НомерUnterhalb des Codes finden Sie eine Erklärung. Auf die gleiche Weise werden wir andere Codefragmente 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 davon ausgegangen, dass es sich bei dieser Adresse um eine Anwendung handelt, die auf solche Anfragen wartet.

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

{
    sentence: "I like yogobella!"
}

3.Wenn eine Antwort auf eine Anfrage eingeht, wird der Status der Komponente aktualisiert. Dadurch wird die Komponente erneut gerendert. Wenn wir Daten erhalten (d. h. ein JSON-Objekt, das die eingegebenen Daten und den berechneten Textwert enthält), geben wir die Komponente aus Polaritysolange die Voraussetzungen 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 recht gut zu funktionieren. Was ist hier überhaupt falsch? Wenn Sie davon ausgehen, dass es an der Adresse, an die die Anwendung eine POST-Anfrage senden möchte, noch nichts gibt, was diese Anfrage annehmen und verarbeiten kann, dann haben Sie völlig Recht. Nämlich, um Anfragen zu bearbeiten, die an die Adresse gehen http://localhost:8080/sentiment, müssen wir eine Webanwendung basierend auf Spring ausführen.

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

▍Einrichten einer Webanwendung basierend auf Spring

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

▍Packen der Anwendung in eine JAR-Datei

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

mvn install

Nachdem Sie diesen Befehl im Ordner ausgeführt haben sa-webapp Verzeichnis wird erstellt target. Hier befindet sich die Java-Anwendung, verpackt in einer JAR-Datei, dargestellt durch die Datei sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Starten einer Java-Anwendung

Gehe in den Ordner target und führen Sie die Anwendung mit dem folgenden Befehl aus:

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

Beim Ausführen dieses Befehls tritt ein Fehler auf. Um mit der Behebung zu beginnen, können wir die Ausnahmedetails 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}"

Für uns ist hier vor allem der Hinweis auf die Unmöglichkeit der Bedeutungsklärung wichtig sa.logic.api.url. Lassen Sie uns den Code analysieren, in dem der Fehler auftritt.

▍Analyse des Java-Anwendungscodes

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 da ist ein Feld saLogicApiUrl. Sein Wert wird durch die Eigenschaft festgelegt sa.logic.api.url.
String saLogicApiUrl verkettet sich mit Wert /analyse/sentiment. Zusammen bilden sie eine Adresse für einen Aufruf des Microservices, der die Textanalyse durchführt.

▍Einen Eigenschaftswert festlegen

In Spring ist die Standardquelle für Eigenschaftswerte eine Datei application.properties, zu finden unter sa-webapp/src/main/resources. Die Verwendung ist jedoch nicht die einzige Möglichkeit, Eigenschaftswerte festzulegen. Sie können dies auch mit dem folgenden Befehl 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 gehen muss, um Textanalyseanfragen zu stellen.

Um unser Leben nicht zu verkomplizieren, werden wir beschließen, dass die Python-Anwendung unter verfügbar sein wird localhost:5000 und versuche es 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

In unserem System fehlt eine Python-Anwendung

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

▍Einrichten einer Python-Anwendung

Um eine Python-Anwendung ausführen zu können, müssen Python 3 und Pip installiert sein und die entsprechenden Umgebungsvariablen müssen korrekt eingestellt 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

▍App-Start

Nachdem die Abhängigkeiten installiert sind, können wir die Anwendung ausführen:

python sentiment_analysis.py

Nach der Ausführung dieses Befehls wird uns Folgendes mitgeteilt:

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

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

▍Code-Recherche

Schauen wir uns den Python-Anwendungscode an, um zu verstehen, wie er 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.
Geben Sie die Adresse an, an die POST-Anfragen gesendet werden sollen.
Abrufen einer Eigenschaft sentence aus dem Anfragetext.
Anonyme Objektinitialisierung TextBlob und den Wert erhalten polarity für den ersten im Hauptteil der Anfrage eingegangenen Vorschlag (in unserem Fall ist dies der einzige zur Analyse eingereichte Vorschlag).
Zurückgeben einer Antwort, deren Text den Text des Angebots und den dafür berechneten Indikator enthält polarity.
Starten der Flask-Anwendung, die unter verfügbar sein wird 0.0.0.0:5000 (Sie können auch über eine Konstruktion des Formulars darauf zugreifen localhost:5000).

Jetzt werden die Microservices ausgeführt, aus denen die Anwendung besteht. Sie sollen miteinander interagieren. So sieht das Anwendungsdiagramm in dieser Arbeitsphase aus.

Alle Microservices, aus denen die Anwendung besteht, werden in einen fehlerfreien Zustand versetzt

Bevor wir fortfahren, öffnen Sie nun die React-App in einem Browser und versuchen Sie, einen Satz damit zu analysieren. Wenn alles richtig gemacht ist - nach dem Drücken der Taste Send Sie sehen die Analyseergebnisse unterhalb des Textfelds.

Im nächsten Abschnitt sprechen wir darüber, wie wir unsere Microservices in Docker-Containern ausführen. Dies ist notwendig, um die Anwendung für die Ausführung im Kubernetes-Cluster vorzubereiten.

Docker-Container

Kubernetes ist ein System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von Containeranwendungen. Es wird auch als „Container-Orchestrator“ bezeichnet. Wenn Kubernetes mit Containern arbeitet, müssen wir vor der Verwendung dieses Systems zunächst diese Container erwerben. Aber lassen Sie uns zunächst darüber sprechen, was Container sind. Die vielleicht beste Antwort auf die Frage, was es ist, findet sich darin Dokumentation an Docker:

Ein Container-Image ist ein leichtes, eigenständiges, ausführbares Paket, das eine Anwendung enthält, die alles enthält, was zu ihrer Ausführung erforderlich ist: Anwendungscode, Laufzeitumgebung, Systemtools und -bibliotheken, Einstellungen. Containerisierte Programme können sowohl in Linux- als auch in Windows-Umgebungen verwendet werden und funktionieren unabhängig von der Infrastruktur immer gleich.

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

Um die Funktionen von Containern zu erkunden und sie mit anderen Methoden zum Ausführen von Anwendungen zu vergleichen, schauen wir uns das Beispiel der Bereitstellung einer React-Anwendung mithilfe einer virtuellen Maschine und eines Containers an.

▍Bereitstellung statischer Dateien einer React-Anwendung mithilfe einer virtuellen Maschine

Beim Versuch, die Wartung statischer Dateien mithilfe virtueller Maschinen zu organisieren, werden wir auf die folgenden Nachteile stoßen:

Ineffiziente Ressourcennutzung, da jede virtuelle Maschine ein vollständiges Betriebssystem ist.
Plattformabhängigkeit. Was auf einem lokalen Computer funktioniert, funktioniert möglicherweise nicht auf einem Produktionsserver.
Langsame und ressourcenintensive Skalierung einer virtuellen Maschinenlösung.

Nginx-Webserver, der statische Dateien bereitstellt, die in einer virtuellen Maschine ausgeführt werden

Werden Container zur Lösung eines ähnlichen Problems eingesetzt, so lassen sich im Vergleich zu virtuellen Maschinen folgende Stärken feststellen:

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

Nginx-Webserver, der statische Dateien bereitstellt, die in einem Container ausgeführt werden

Wir haben virtuelle Maschinen und Container nur in einigen wenigen Punkten verglichen, aber selbst das reicht aus, um ein Gefühl für die Stärken von Containern zu bekommen. Hier Hier finden Sie Details zu Docker-Containern.

▍Erstellen eines Container-Images für eine React-App

Der Grundbaustein eines Docker-Containers ist die Datei Dockerfile. Am Anfang dieser Datei wird ein Basisbild des Containers aufgezeichnet. Anschließend wird eine Folge von Anweisungen eingefügt, die angeben, wie ein Container erstellt wird, der die Anforderungen einer Anwendung erfüllt.

Bevor wir beginnen, mit der Datei zu arbeiten DockerfileDenken Sie daran, was wir getan haben, um die Dateien der React-Anwendung für das Hochladen auf den Nginx-Server vorzubereiten:

Erstellen eines React-App-Pakets (npm run build).
Starten des Nginx-Servers.
Kopieren des Inhalts eines 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 genannten Aktionen, die auf dem lokalen Computer ausgeführt werden.

▍Vorbereiten einer Docker-Datei für die SA-Frontend-Anwendung

Anweisungen, die darin enthalten sein müssen Dockerfile für die Anwendung SA-Frontend, bestehen nur aus zwei Befehlen. Tatsache ist, dass das Nginx-Entwicklungsteam eine Grundlage vorbereitet hat Bild für Nginx, mit dem wir unser Image erstellen werden. Hier sind die beiden Schritte, die wir beschreiben müssen:

Sie müssen das Nginx-Image zur Grundlage des Images machen.
Ordnerinhalt sa-frontend/build müssen in den Bildordner kopiert werden nginx/html.

Wenn wir von dieser Beschreibung zur Datei gehen Dockerfile, dann sieht es so aus:

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

Wie Sie sehen, ist hier alles sehr einfach, während sich der Inhalt der Datei sogar als recht lesbar und verständlich herausstellt. Diese Datei weist das System an, das Bild aufzunehmen nginx mit allem, was es bereits hat, und kopieren Sie den Inhalt des Verzeichnisses build zum Verzeichnis nginx/html.

Hier haben Sie möglicherweise eine Frage dazu, woher ich genau weiß, wohin ich die Dateien aus dem Ordner kopieren muss build, also woher kam der Weg /usr/share/nginx/html. Tatsächlich gibt es auch hier nichts Kompliziertes. Tatsache ist, dass die relevanten Informationen in zu finden sind Beschreibung Bild.

▍Zusammenstellen des Bildes und Hochladen in das Repository

Bevor wir mit einem fertigen Bild arbeiten können, müssen wir es an das Bild-Repository senden. Dazu nutzen wir die kostenlose cloudbasierte Image-Hosting-Plattform Docker Hub. In dieser Arbeitsphase müssen Sie Folgendes tun:

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

Jetzt müssen Sie mit dem Terminal in das Verzeichnis gehen sa-frontend und führen Sie dort den folgenden Befehl aus:

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

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

In diesem Fall kann dieser Befehl durch Entfernen gekürzt werden -f Dockerfile, da der Ordner, in dem wir diesen Befehl ausführen, diese Datei bereits enthält.

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

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Überprüfen Sie nach Abschluss die Liste Ihrer Repositorys auf Docker Hub, um festzustellen, ob das Image erfolgreich in den Cloud-Speicher übertragen wurde.

▍Starten eines Containers

Jetzt kann jeder das Image herunterladen und ausführen $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 läuft der Container und wir können weiterarbeiten, indem wir weitere benötigte Images erstellen. Aber bevor wir fortfahren, wollen wir das Design verstehen 80:80, das im Befehl zum Ausführen des Bildes enthalten ist und möglicherweise verwirrend erscheint.

Erste Nummer 80 ist die Portnummer des Hosts (d. h. des lokalen Computers).
Zweite Nummer 80 ist der Port des Containers, an den die Anfrage umgeleitet werden soll.

Betrachten Sie die folgende Abbildung.

Port-Weiterleitung

Das System leitet Anfragen vom Port weiter <hostPort> pro Hafen <containerPort>. Das heißt, auf den Port zugreifen 80 Computer wird auf einen Port umgeleitet 80 Container.

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

Sobald der Front-End-App-Container erfolgreich gestartet wurde, sollten Sie zu diesem Zeitpunkt in der Lage sein, seine Seite in einem Browser zu öffnen.

▍.dockerignore-Datei

Erstellen des Anwendungsimages SA-Frontendkonnten wir feststellen, dass dieser Prozess extrem langsam ist. Dies liegt daran, dass der Image-Build-Kontext an den Docker-Daemon gesendet werden muss. Das Verzeichnis, das den Build-Kontext darstellt, wird als letztes Argument für den Befehl angegeben docker build. In unserem Fall befindet sich am Ende dieses Befehls ein Punkt. Dies führt dazu, dass die folgende Struktur in den Assembly-Kontext 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 einen Ordner build. Alles andere herunterzuladen ist Zeitverschwendung. Sie können den Build beschleunigen, indem Sie Docker mitteilen, welche Verzeichnisse ignoriert werden sollen. Dazu benötigen wir eine Datei .dockerignore. Sie, wenn Sie mit der Datei vertraut sind .gitignore, wird Ihnen die Struktur dieser Datei wahrscheinlich bekannt vorkommen. Es listet Verzeichnisse auf, die das Image-Build-System ignorieren kann. In unserem Fall sieht der Inhalt dieser Datei so aus:

node_modules
src
public

Datei .dockerignore muss sich im selben Ordner wie die Datei befinden Dockerfile. Der Zusammenbau des Bildes dauert nun einige Sekunden.

Befassen wir uns nun mit dem Image für eine Java-Anwendung.

▍Erstellen eines Container-Images für eine Java-Anwendung

Wissen Sie was, und Sie haben bereits alles gelernt, was Sie zum Erstellen von Container-Images benötigen. Deshalb wird dieser Abschnitt sehr kurz sein.

Öffne die Datei Dockerfile, die sich im Projektordner befindet sa-webapp. Wenn Sie den Text dieser Datei lesen, werden Sie darin nur auf zwei neue Konstruktionen stoßen, die mit Schlüsselwörtern beginnen ENV и EXPOSE:

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

Ключевое слово ENV ermöglicht Ihnen die Deklaration von Umgebungsvariablen in Docker-Containern. In unserem Fall können Sie damit insbesondere eine URL festlegen, um auf die API der Anwendung zuzugreifen, die die Textanalyse durchführt.

Ключевое слово EXPOSE ermöglicht es Ihnen, Docker anzuweisen, einen Port zu öffnen. Wir werden diesen Port verwenden, während wir mit der Anwendung arbeiten. Hier können Sie das sehen Dockerfile für die Anwendung SA-Frontend Es gibt keinen solchen Befehl. Dies dient nur zu Dokumentationszwecken, mit anderen Worten, dieses Konstrukt ist für den Leser bestimmt Dockerfile.

Das Erstellen des Images und das Verschieben in das Repository sieht genauso aus wie im vorherigen Beispiel. Wenn Sie sich Ihrer Fähigkeiten noch nicht so sicher sind, finden Sie die entsprechenden Befehle in der Datei README.md im Ordner sa-webapp.

▍Erstellen eines Container-Images für eine Python-Anwendung

Schauen Sie sich den Inhalt der Datei an Dockerfile im Ordner sa-logicDa wirst du nichts Neues finden. Die Befehle zum Erstellen des Images und zum Verschieben in das Repository sollten Ihnen bereits bekannt sein, sind aber wie bei unseren anderen Anwendungen in der Datei zu finden README.md im Ordner sa-logic.

▍Testen von Containeranwendungen

Kann man etwas vertrauen, das man nicht getestet hat? Ich kann auch nicht. Testen wir unsere Container.

Starten wir den Anwendungscontainer sa-logic und konfigurieren Sie es so, dass es einen Port überwacht 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Starten wir den Anwendungscontainer sa-webapp und konfigurieren Sie es so, dass es einen Port überwacht 8080. Darüber hinaus müssen wir den Port festlegen, an dem die Python-Anwendung auf Anfragen von der Java-Anwendung lauscht, indem wir die Umgebungsvariable neu zuweisen 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
```

Informationen zum Ermitteln der IP-Adresse eines Containers oder einer Docker-VM finden Sie in der Datei README.

Starten wir den Anwendungscontainer sa-frontend:

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

Jetzt ist alles bereit, im Browser zur Adresse zu navigieren localhost:80 und testen Sie die App.

Bitte beachten Sie, dass, wenn Sie den Port für ändern sa-webapp, oder wenn Sie eine Docker-VM ausführen, müssen Sie die Datei bearbeiten App.js aus Ordner sa-frontenddurch Ändern der IP-Adresse oder Portnummer in der Methode analyzeSentence()durch den Ersatz veralteter Daten durch aktuelle Informationen. Danach müssen Sie das Bild wieder zusammensetzen und verwenden.

So sieht unser Anwendungsdiagramm jetzt aus.

Microservices werden in Containern ausgeführt

Zusammenfassung: Warum brauchen wir einen Kubernetes-Cluster?

Wir haben gerade die Dateien überprüft Dockerfile, sprach darüber, wie man Images erstellt und sie in ein Docker-Repository überträgt. Darüber hinaus haben wir gelernt, wie wir die Zusammenstellung von Bildern mithilfe der Datei beschleunigen können .dockerignore. Dadurch laufen unsere Microservices nun in Docker-Containern. Hier haben Sie möglicherweise eine völlig berechtigte Frage, warum wir Kubernetes brauchen. Der Antwort auf diese Frage wird der zweite Teil dieses Materials gewidmet sein. Bedenken Sie in der Zwischenzeit die folgende Frage:
Nehmen wir an, dass unsere Webanwendung zur Textanalyse weltweit populär geworden ist. Jede Minute erreichen ihn Millionen von Anfragen. Das bedeutet, dass Microservices sa-webapp и sa-logic wird unter enormem Stress stehen. Wie skaliert man Container, die Microservices ausführen?

Source: habr.com

Kubernetes-Tutorial Teil 1: Anwendungen, Microservices und Container