Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Stellen Sie einen Beispiel-Java-Microservice auf Amazon EKS bereit und machen Sie den Microservice mithilfe eines Application Load Balancer verfügbar
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer"></a>

*Vijay Thompson und Akkamahadevi Hiremath, Amazon Web Services*

## Zusammenfassung
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-summary"></a>

Dieses Muster beschreibt, wie ein Java-Microservice als containerisierte Anwendung auf Amazon Elastic Kubernetes Service (Amazon EKS) mithilfe des `eksctl` Befehlszeilenprogramms und Amazon Elastic Container Registry (Amazon ECR) bereitgestellt wird. Sie können einen Application Load Balancer für den Lastenausgleich des Anwendungsdatenverkehrs verwenden.

## Voraussetzungen und Einschränkungen
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-prereqs"></a>

**Voraussetzungen**
+ Ein aktives AWS-Konto
+ Die AWS-Befehlszeilenschnittstelle (AWS CLI) Version 1.7 oder höher, installiert und konfiguriert auf macOS, Linux oder Windows
+ Ein laufender [Docker-Daemon](https://docs.docker.com/config/daemon/)
+ Das `eksctl` Befehlszeilenprogramm, installiert und konfiguriert auf macOS, Linux oder Windows (Weitere Informationen finden Sie unter [Erste Schritte mit Amazon EKS — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) in der Amazon EKS-Dokumentation.)
+ Das `kubectl` Befehlszeilenprogramm, installiert und konfiguriert unter macOS, Linux oder Windows (Weitere Informationen finden Sie unter [Installation oder Aktualisierung von kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) in der Amazon EKS-Dokumentation.)

**Einschränkungen**
+ Dieses Muster deckt die Installation eines SSL-Zertifikats für den Application Load Balancer nicht ab.

## Architektur
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-architecture"></a>

**Zieltechnologie-Stack**
+ Amazon ECR
+ Amazon EKS
+ Elastic Load Balancing

**Zielarchitektur**

Das folgende Diagramm zeigt eine Architektur für die Containerisierung eines Java-Microservices auf Amazon EKS.

![\[Ein Java-Microservice, der als containerisierte Anwendung auf Amazon EKS bereitgestellt wird.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/e1dd8ab0-9e1e-4d2b-b7af-89d3e583e57c/images/aaca4fd9-5aaa-4df5-aebd-02a2ed881c3b.png)


## Tools
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-tools"></a>
+ [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) ist ein verwalteter Container-Image-Registry-Service, der sicher, skalierbar und zuverlässig ist.
+ [Amazon Elastic Kubernetes Service (Amazon EKS)](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) hilft Ihnen dabei, Kubernetes auf AWS auszuführen, ohne Ihre eigene Kubernetes-Steuerebene oder Knoten installieren oder verwalten zu müssen.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie über Befehle in Ihrer Befehlszeilen-Shell mit AWS-Services interagieren können.
+ [Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) verteilt Ihren eingehenden Traffic automatisch auf mehrere Ziele, wie Amazon Elastic Compute Cloud (Amazon EC2) -Instances, Container und IP-Adressen, in einer oder mehreren Availability Zones.
+ [eksctl](https://eksctl.io/) hilft Ihnen bei der Erstellung von Clustern auf Amazon EKS.
+ [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) ermöglicht die Ausführung von Befehlen für Kubernetes-Cluster.
+ [Docker](https://www.docker.com/) hilft Ihnen beim Erstellen, Testen und Bereitstellen von Anwendungen in Paketen, die als Container bezeichnet werden.

## Epen
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-epics"></a>

### Erstellen Sie einen Amazon EKS-Cluster mithilfe von eksctl
<a name="create-an-amazon-eks-cluster-by-using-eksctl"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Erstellen Sie einen Amazon-EKS-Cluster.  | Um einen Amazon EKS-Cluster zu erstellen, der zwei t2.small EC2 Amazon-Instances als Knoten verwendet, führen Sie den folgenden Befehl aus:<pre>eksctl create cluster --name <your-cluster-name> --version <version-number> --nodes=1 --node-type=t2.small</pre>Der Vorgang kann zwischen 15 und 20 Minuten dauern. Nachdem der Cluster erstellt wurde, wird die entsprechende Kubernetes-Konfiguration zu Ihrer [kubeconfig-Datei](https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html) hinzugefügt. Sie können die `kubeconfig` Datei mit verwenden, `kubectl`**** um die Anwendung in späteren Schritten bereitzustellen. | Entwickler, Systemadministrator | 
| Überprüfen Sie den Amazon EKS-Cluster. | Um zu überprüfen, ob der Cluster erstellt wurde und Sie eine Verbindung zu ihm herstellen können, führen Sie den `kubectl get nodes` Befehl aus. | Entwickler, Systemadministrator | 

### Erstellen Sie ein Amazon ECR-Repository und übertragen Sie das Docker-Image.
<a name="create-an-amazon-ecr-repository-and-push-the-docker-image"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Erstellen Sie ein Amazon-ECR-Repository. | Folgen Sie den Anweisungen unter [Erstellen eines privaten Repositorys](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) in der Amazon ECR-Dokumentation. | Entwickler, Systemadministrator | 
| Erstellen Sie eine POM-XML-Datei. | Erstellen Sie eine `pom.xml` Datei, die auf dem *POM-Beispieldateicode* im Abschnitt [Zusätzliche Informationen](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) dieses Musters basiert. | Entwickler, Systemadministrator | 
| Erstellen Sie eine Quelldatei. | Erstellen Sie anhand des folgenden `HelloWorld.java` Beispiels eine Quelldatei mit dem Namen im `src/main/java/eksExample` Pfad:<pre>package eksExample;<br />import static spark.Spark.get;<br /><br />public class HelloWorld {<br />    public static void main(String[] args) {<br />        get("/", (req, res) -> {<br />            return "Hello World!";<br />        });<br />    }<br />}</pre>Achten Sie darauf, die folgende Verzeichnisstruktur zu verwenden:<pre>├── Dockerfile<br />├── deployment.yaml<br />├── ingress.yaml<br />├── pom.xml<br />├── service.yaml<br />└── src<br />    └── main<br />        └── java<br />            └── eksExample<br />                └── HelloWorld.java</pre> |  | 
| Erstellen Sie eine Docker-Datei. | Erstellen Sie einen auf dem *Dockerfile-Beispiel `Dockerfile`* basierenden Code im Abschnitt [Zusätzliche Informationen](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) dieses Musters. | Entwickler, Systemadministrator | 
| Erstellen Sie das Docker-Image und übertragen Sie es. | Führen Sie in dem Verzeichnis, in dem Sie das Image erstellen, taggen und an Amazon ECR übertragen möchten, die folgenden Befehle aus: `Dockerfile`<pre>aws ecr get-login-password --region <region>| docker login --username <username> --password-stdin <account_number>.dkr.ecr.<region>.amazonaws.com<br />docker buildx build --platform linux/amd64 -t hello-world-java:v1 .<br />docker tag hello-world-java:v1 <account_number>.dkr.ecr.<region>.amazonaws.com/<repository_name>:v1<br />docker push <account_number>.dkr.ecr.<region>.amazonaws.com/<repository_name>:v1</pre>Ändern Sie die AWS-Region, die Kontonummer und die Repository-Details in den vorherigen Befehlen. Notieren Sie sich unbedingt die Bild-URL für die spätere Verwendung.Ein macOS-System mit einem M1-Chip hat ein Problem beim Erstellen eines Images, das mit Amazon EKS kompatibel ist, das auf einer AMD64 Plattform ausgeführt wird. Um dieses Problem zu beheben, verwenden Sie [docker buildx](https://docs.docker.com/engine/reference/commandline/buildx/), um ein Docker-Image zu erstellen, das auf Amazon EKS funktioniert. |  | 

### Stellen Sie die Java-Microservices bereit
<a name="deploy-the-java-microservices"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Erstellen Sie eine Bereitstellungsdatei.  | Erstellen Sie eine YAML-Datei, die `deployment.yaml` auf dem Code der *Beispiel-Bereitstellungsdatei* im Abschnitt [Zusätzliche Informationen](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) dieses Musters basiert.Verwenden Sie die Bild-URL, die Sie zuvor kopiert haben, als Pfad der Bilddatei für das Amazon ECR-Repository. | Entwickler, Systemadministrator | 
| Stellen Sie die Java-Microservices auf dem Amazon EKS-Cluster bereit.  | Führen Sie den `kubectl apply -f deployment.yaml` Befehl aus, um eine Bereitstellung in Ihrem Amazon EKS-Cluster zu erstellen. | Entwickler, Systemadministrator | 
| Überprüfen Sie den Status der Pods. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer.html) | Entwickler, Systemadministrator | 
| Erstellen Sie einen Service. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer.html) | Entwickler, Systemadministrator | 
| Installieren Sie das AWS Load Balancer Controller-Add-on. | Folgen Sie den Anweisungen unter [Installation des AWS Load Balancer Controller-Add-ons](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html) in der Amazon EKS-Dokumentation.Sie müssen das Add-on installiert haben, um einen Application Load Balancer oder Network Load Balancer für einen Kubernetes-Dienst zu erstellen. | Entwickler, Systemadministrator | 
| Erstellen Sie eine Eingangsressource. | Erstellen Sie eine YAML-Datei, die auf der `ingress.yaml` Grundlage des *Beispielcodes für eine Ingress-Ressourcendatei* im Abschnitt [Zusätzliche Informationen dieses Musters](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) aufgerufen wird. | Entwickler, Systemadministrator | 
| Erstellen Sie einen Application Load Balancer. | Führen Sie den Befehl aus, um die Eingangsressource bereitzustellen und einen Application Load Balancer zu erstellen. `kubectl apply -f ingress.yaml` | Entwickler, Systemadministrator | 

### Testen der Anwendung
<a name="test-the-application"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Testen und verifizieren Sie die Anwendung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer.html) | Entwickler, Systemadministrator | 

## Zugehörige Ressourcen
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-resources"></a>
+ [Ein privates Repository erstellen](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) (Amazon ECR-Dokumentation)
+ [Ein Docker-Image pushen](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) (Amazon ECR-Dokumentation)
+ [Eingangscontroller](https://www.eksworkshop.com/beginner/130_exposing-service/ingress_controller_alb/) (Amazon EKS-Workshop)
+ [Docker buildx (Docker-Dokumente](https://docs.docker.com/engine/reference/commandline/buildx/))

## Zusätzliche Informationen
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional"></a>

**Beispiel für eine POM-Datei**

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>


  <groupId>helloWorld</groupId>
  <artifactId>helloWorld</artifactId>
  <version>1.0-SNAPSHOT</version>


  <dependencies>
    <dependency>
      <groupId>com.sparkjava</groupId><artifactId>spark-core</artifactId><version>2.0.0</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId><artifactId>maven-jar-plugin</artifactId><version>2.4</version>
        <configuration><finalName>eksExample</finalName><archive><manifest>
              <addClasspath>true</addClasspath><mainClass>eksExample.HelloWorld</mainClass><classpathPrefix>dependency-jars/</classpathPrefix>
            </manifest></archive>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.1</version>
        <configuration><source>1.8</source><target>1.8</target></configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId><artifactId>maven-assembly-plugin</artifactId>
        <executions>
          <execution>
            <goals><goal>attached</goal></goals><phase>package</phase>
            <configuration>
              <finalName>eksExample</finalName>
              <descriptorRefs><descriptorRef>jar-with-dependencies</descriptorRef></descriptorRefs>
              <archive><manifest><mainClass>eksExample.HelloWorld</mainClass></manifest></archive>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>
```

**Beispiel Dockerfile**

```
FROM bellsoft/liberica-openjdk-alpine-musl:17

RUN apk add maven
WORKDIR /code

# Prepare by downloading dependencies
ADD pom.xml /code/pom.xml
RUN ["mvn", "dependency:resolve"]
RUN ["mvn", "verify"]

# Adding source, compile and package into a fat jar
ADD src /code/src
RUN ["mvn", "package"]

EXPOSE 4567
CMD ["java", "-jar", "target/eksExample-jar-with-dependencies.jar"]
```

**Beispiel für eine Bereitstellungsdatei**

```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: microservice-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app.kubernetes.io/name: java-microservice
  template:
    metadata:
      labels:
        app.kubernetes.io/name: java-microservice
    spec:
      containers:
      - name: java-microservice-container
        image: .dkr.ecr.amazonaws.com/:
        ports:
        - containerPort: 4567
```

**Beispiel für eine Servicedatei**

```
apiVersion: v1
kind: Service
metadata:
  name: "service-java-microservice"
spec:
  ports:
    - port: 80
      targetPort: 4567
      protocol: TCP
  type: NodePort
  selector:
    app.kubernetes.io/name: java-microservice
```

**Beispiel für eine Ingress-Ressourcendatei**

```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: "java-microservice-ingress"
  annotations:
    kubernetes.io/ingress.class: alb
    alb.ingress.kubernetes.io/load-balancer-name: apg2
    alb.ingress.kubernetes.io/target-type: ip
  labels:
    app: java-microservice
spec:
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: "service-java-microservice"
                port:
                  number: 80
```