Java >> Java Tutorial >  >> Java

Eine Schritt-für-Schritt-Anleitung für Kubernetes

Java

In diesem Beitrag besprechen wir die Verwendung von Kubernetes und die Bereitstellung Ihres Microservices in einem Kubernetes-Cluster. Ich werde die Grundlagen behandeln. Wenn Sie also Anfänger sind, ist dies eine gute Schritt-für-Schritt-Anleitung zum Erlernen von Kubernetes. Da wir eine dockerisierte Containeranwendung erstellen, können Sie mit der vollständigen Anleitung zur Verwendung von docker-compose beginnen.

Was ist Kubernetes?

Laut Originalquelle – Kubernetes ist ein Open-Source-System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen. Kubernetes ist eine Container-Orchestrierungsplattform.

Sobald Sie eine containerisierte Anwendung haben, können Sie diese grundsätzlich auf dem Kubernetes-Cluster bereitstellen. Insbesondere enthält der Cluster mehrere Maschinen oder Server.

In einer herkömmlichen Java-Anwendung würde man eine JAR-Datei erstellen und diese auf einem Servercomputer bereitstellen. Stellen Sie manchmal sogar dieselbe Anwendung auf mehreren Computern bereit, um horizontal zu skalieren. Vor allem müssen Sie sich bei Kubernetes keine Sorgen um Servermaschinen machen. Offensichtlich ermöglicht Kubernetes die Erstellung eines Clusters von Maschinen und die Bereitstellung Ihrer containerisierten Anwendung darauf.

Darüber hinaus kann man mit Kubernetes

  • Container über mehrere Hosts hinweg orchestrieren
  • Steuern und automatisieren Sie die Anwendungsbereitstellung
  • Serverressourcen besser verwalten
  • Gesundheitsprüfung und Selbstreparatur Ihrer Apps mit automatischer Platzierung, automatischem Neustart, automatischer Replikation und automatischer Skalierung

Darüber hinaus besteht der Kubernetes-Cluster aus zwei Teilen

  1. Eine Kontrollebene
  2. Eine Rechenmaschine

Insbesondere die Knoten (physische Maschinen oder virtuelle Maschinen) interagieren mit der Steuerungsebene über die Kubernetes-API.

  • Steuerungsebene – Die Sammlung von Prozessen, die die Kubernetes-Knoten steuern.
  • Knoten – Die Maschinen, die die Aufgaben ausführen, die durch Prozesse zugewiesen werden.
  • Pod – Eine Gruppe von einem oder mehreren Containern, die auf einem einzelnen Knoten bereitgestellt werden. Alle Container auf dem Pod teilen sich die Ressourcen und IP-Adressen.
  • Service – Eine abstrakte Möglichkeit, eine Anwendung, die auf einer Reihe von Pods ausgeführt wird, als Netzwerkdienst verfügbar zu machen.
  • Kubelet – Das Kubelet ist ein primärer Knotenagent, der auf jedem Knoten ausgeführt wird. Es liest die Container-Manifeste und verfolgt Container, die gestartet und ausgeführt werden.
  • kubectl – Das Befehlszeilen-Konfigurationstool für Kubernetes

Wie erstelle ich einen Cluster?

Laden Sie danach je nach Ihrer Umgebung Minikube herunter. Ich verwende eine Windows-Umgebung.

minikube start erstellt einen neuen Kubernetes-Cluster.

Wenn Sie sich schließlich ein detaillierteres Dashboard ansehen möchten, können Sie den Befehl minikube dashboard verwenden . Dieser Befehl startet ein Kubernetes-Dashboard im Browser. (http://127.0.0.1:60960/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-dashboard:/proxy/ )

Demo zur Bereitstellung eines Microservices in Kubernetes

Erstellen Sie einen containerisierten Microservice

Lassen Sie uns außerdem einen einfachen Microservice erstellen, den wir schließlich im Cluster bereitstellen werden. Ich werde Spring Boot verwenden, um einen Microservice zu erstellen, der eine Liste von Produkten für einen REST-API-Aufruf zurückgibt.

Dieser Microservice gibt beim Aufruf eine Liste der Produkte zurück.


package com.betterjavacode.kubernetesdemo.controllers;

import com.betterjavacode.kubernetesdemo.dtos.ProductDTO;
import com.betterjavacode.kubernetesdemo.services.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/v1/products")
public class ProductController
{
    @Autowired
    public ProductService productService;

    @GetMapping
    public List getAllProducts()
    {
        return productService.getAllProducts();
    }
}

Außerdem die ProductService wird eine einzige Methode haben, um alle Produkte zurückzugeben.


package com.betterjavacode.kubernetesdemo.services;

import com.betterjavacode.kubernetesdemo.dtos.ProductDTO;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Component
public class ProductService
{

    public List getAllProducts ()
    {
        List productDTOS = new ArrayList<>();

        ProductDTO toothbrushProductDTO = new ProductDTO("Toothbrush", "Colgate", "A toothbrush " +
                "for " +
                "all");
        ProductDTO batteryProductDTO = new ProductDTO("Battery", "Duracell", "Duracell batteries " +
                "last long");

        productDTOS.add(toothbrushProductDTO);
        productDTOS.add(batteryProductDTO);
        return productDTOS;

    }
}

Ich verwende bewusst keine Datenbank und verwende eine statische Liste von Produkten, die zu Demozwecken zurückgesendet werden.

Bevor Sie ein Docker-Image erstellen, führen Sie

aus

minikube docker-env

minikube docker-env | Invoke-Expression

Docker-Image erstellen

Lassen Sie uns ein Docker-Image für unseren gerade erstellten Microservice erstellen. Erstellen Sie zunächst eine Dockerdatei im Stammverzeichnis Ihres Projekts.

FROM openjdk:8-jdk-alpine
VOLUME /tmp
COPY ./build/libs/*.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

Lassen Sie uns nun ein Docker-Image mit dieser Docker-Datei erstellen.

docker build -t kubernetesdemo .

Dadurch wird ein kubernetesdemo erstellt Docker-Image mit dem neuesten Tag.

Wenn Sie dieses Image in Ihrer lokalen Umgebung ausprobieren möchten, können Sie es mit dem folgenden Befehl ausführen:

docker run --name kubernetesdemo -p 8080:8080 kubernetesdemo

Dadurch wird unser Microservice-Docker-Image auf Port 8080 ausgeführt. Unabhängig davon müssen wir dieses Docker-Image vor der Bereitstellung in Kubernetes in die Docker-Hub-Containerregistrierung übertragen, damit Kubernetes vom Hub abrufen kann.

docker login – Melden Sie sich mit Ihrem Benutzernamen und Passwort von Ihrem Terminal aus beim Docker-Hub an.

Sobald die Anmeldung erfolgreich ist, müssen wir ein Tag für unser Docker-Image erstellen.

docker tag kubernetesdemo username/kubernetesdemo:1.0.0 .

Verwenden Sie Ihren Docker-Hub-Benutzernamen.

Jetzt werden wir dieses Bild mit dem Befehl:

auf den Docker-Hub übertragen

docker push username/kubernetesdemo:1.0.0 .

Jetzt befindet sich unser Docker-Image in der Containerregistrierung.

Kubernetes-Bereitstellung

Kubernetes ist ein Container-Orchestrator, der entwickelt wurde, um komplexe Anwendungen unter Berücksichtigung der Skalierbarkeit auszuführen.

Der Container Orchestrator verwaltet die Container rund um die Server. Das ist die einfache Definition. Wie bereits erwähnt, erstellen wir mit dem Befehl

einen lokalen Cluster auf einem Windows-Computer

minikube start .

Sobald der Cluster gestartet ist, können wir uns die Cluster-Info mit dem Befehl

ansehen

kubectl get cluster-info .

Um nun unseren Microservice in Kubernetes bereitzustellen, verwenden wir die deklarative Schnittstelle.

Bereitstellungsdatei deklarieren

Erstellen Sie eine kube Verzeichnis unter dem Stammverzeichnis Ihres Projekts. Fügen Sie yaml hinzu Datei namens deployment.yaml .

Diese Datei sieht wie folgt aus:

apiVersion: v1
kind: Service
metadata:
  name: kubernetesdemo
spec:
  selector:
    app: kubernetesdemo
  ports:
    - port: 80
      targetPort: 8080
  type: LoadBalancer

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: kubernetesdemo
spec:
  selector:
    matchLabels:
      app: kubernetesdemo
  replicas: 3
  template:
    metadata:
      labels:
        app: kubernetesdemo
    spec:
      containers:
      - name: kubernetesdemo
        image: username/kubernetesdemo:1.0.0
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

In Kürze werden wir jeden Abschnitt dieser Bereitstellungsdatei durchgehen.

Sobald wir diese Bereitstellungsdatei ausführen, werden ein Container und ein Dienst erstellt. Schauen wir uns zuerst Deployment an .

apiVersion: apps/v1 
kind: Deployment 
metadata: 
  name: kubernetesdemo

Diese Zeilen deklarieren, dass wir eine Ressource vom Typ Deployment erstellen mit Version v1 und dem Namen kubernetesdemo .

replicas: 3 zeigen an, dass wir 3 Replikate des Containers ausführen. Aber der Container hier ist nichts als eine Kapsel. Ein Pod ist eine Hülle um einen Behälter. Ein einzelner Pod kann mehrere Container ausführen, während die Container die Ressourcen des Pods gemeinsam nutzen. Denken Sie daran, dass der Pod die kleinste Bereitstellungseinheit in Kubernetes ist.

Die template.metadata.labels definiert das Label für den Pod, der den Container für die Anwendung kubernetesdemo ausführt .

Der Abschnitt von containers ist selbsterklärend. Wenn es nicht klar ist, deklarieren wir hier den Container, den wir in einem Pod ausführen möchten. Der Name des Containers kubernetesdemo und das Bild dieses Containers ist username/kubernetesdemo:1.0.0 . Wir werden den Port 8080 dieses Containers verfügbar machen, in dem unser Microservice ausgeführt wird.

Dienstdefinition

Schauen wir uns ohne Verzögerung den früheren Teil dieser Bereitstellungsdatei an.

apiVersion: v1
kind: Service
metadata:
  name: kubernetesdemo
spec:
  selector:
    app: kubernetesdemo
  ports:
    - port: 80
      targetPort: 8080
  type: LoadBalancer

Hier erstellen wir eine Ressource vom Typ Service .

Ein Dienst ermöglicht es Pods, mit anderen Pods zu kommunizieren. Aber es ermöglicht auch externen Benutzern den Zugriff auf Pods. Ohne einen Dienst kann man nicht auf Pods zugreifen. Die Art von Dienst, die wir hier definieren, ermöglicht es uns, den Datenverkehr an einen bestimmten Pod weiterzuleiten.

In dieser Deklaration spec.selector.app ermöglicht es uns, den Pod mit dem Namen kubernetesdemo auszuwählen . Der Dienst stellt diesen Pod bereit. Eine an Port 80 eingehende Anfrage wird an den Zielport 8080 des ausgewählten Pods weitergeleitet.

Und schließlich ist der Dienst vom Typ LoadBalancer . Grundsätzlich fungiert in unserem Kubernetes-Cluster ein Dienst als Load Balancer, der den Datenverkehr an verschiedene Pods weiterleitet. Ein Service stellt die kontinuierliche Verfügbarkeit von Anwendungen sicher. Wenn ein Pod abstürzt, startet ein anderer Pod und der Dienst stellt sicher, dass der Datenverkehr entsprechend weitergeleitet wird.

Der Dienst verfolgt alle Replikate, die Sie im Cluster ausführen.

Bereitstellung ausführen

Bisher haben wir eine Bereitstellungskonfiguration erstellt, um Ressourcen in unserem Cluster zu erstellen. Aber wir haben noch nichts bereitgestellt.

Um die Bereitstellung auszuführen, verwenden Sie

kubectl apply -f deployment.yaml

Sie können auch einfach laufen

kubectl apply -f kube und es holt Bereitstellungsdateien von kube ab Verzeichnis.

Die Antwort auf diesen Befehl lautet

service/kubernetesdemo configured
deployment.apps/kubernetesdemo created

kubectl get pods zeigt den Status der Pods an

Um nun die tatsächliche Situation mit laufenden Clustern und Diensten zu sehen, können wir

verwenden

minikube dashboard .

Wir können sehen, dass 3 Pods für unseren Microservice kubernetesdemo ausgeführt werden .

Wenn Sie kubectl get services ausführen , sehen wir alle laufenden Dienste. Um nun auf unsere Anwendung zuzugreifen, müssen wir die Service-URL finden. In diesem Fall lautet der Name des Dienstes (nicht des Mikrodienstes) kubernetesdemo .

minikube service kubernetesdemo --url zeigt eine URL im Terminalfenster an.

Verwenden Sie nun diese URL http://127.0.0.1:49715/v1/products , können wir die Ausgabe im Browser sehen

Wie skaliert man?

Mit Kubernetes ist es einfach, die Anwendung zu skalieren. Wir verwenden bereits 3 Replikate, aber wir können die Anzahl mit einem Befehl verringern oder erhöhen:

kubectl scale --replicas=4 deployment/kubernetesdemo .

Wenn Sie das Dashboard haben, sehen Sie die 4. Replik beginnen. Das ist alles.

Schlussfolgerung

Wow, wir haben in dieser Demo viel behandelt. Ich hoffe, ich konnte die grundlegenden Konzepte von Kubernetes Schritt für Schritt erklären. Wenn Sie mehr erfahren möchten, kommentieren Sie diesen Beitrag. Wenn Sie Spring Security-Konzepte kennenlernen möchten, können Sie mein Buch Simplifying Spring Security kaufen.


Java-Tag