Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Implementa un microservizio Java di esempio su Amazon EKS ed esponi il microservizio utilizzando un Application Load Balancer
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer"></a>

*Vijay Thompson e Akkamahadevi Hiremath, Amazon Web Services*

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

Questo modello descrive come distribuire un microservizio Java di esempio come applicazione containerizzata su Amazon Elastic Kubernetes Service (Amazon EKS) utilizzando `eksctl` l'utilità da riga di comando e Amazon Elastic Container Registry (Amazon ECR). È possibile utilizzare un Application Load Balancer per bilanciare il carico del traffico dell'applicazione.

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

**Prerequisiti**
+ Un account AWS attivo
+ La versione 1.7 o successiva dell'interfaccia a riga di comando AWS (AWS CLI), installata e configurata su macOS, Linux o Windows
+ [Un demone Docker in esecuzione](https://docs.docker.com/config/daemon/)
+ L'utilità da riga di `eksctl` comando, installata e configurata su macOS, Linux o Windows (per ulteriori informazioni, consulta la sezione [Guida introduttiva ad Amazon EKS — eksctl nella documentazione di Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)).
+ L'utilità da riga di `kubectl` comando, installata e configurata su macOS, Linux o Windows (per ulteriori informazioni, consulta [Installazione o aggiornamento di kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) nella documentazione di Amazon EKS).

**Limitazioni**
+ Questo modello non copre l'installazione di un certificato SSL per Application Load Balancer.

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

**Stack tecnologico Target**
+ Amazon ECR
+ Amazon EKS
+ Elastic Load Balancing

**Architettura di destinazione**

Il diagramma seguente mostra un'architettura per la containerizzazione di un microservizio Java su Amazon EKS.

![\[Un microservizio Java distribuito come applicazione containerizzata su Amazon EKS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/e1dd8ab0-9e1e-4d2b-b7af-89d3e583e57c/images/aaca4fd9-5aaa-4df5-aebd-02a2ed881c3b.png)


## Tools (Strumenti)
<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)) è un servizio di registro di immagini di container gestito sicuro, scalabile e affidabile.
+ [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) EKS) ti aiuta a eseguire Kubernetes su AWS senza dover installare o gestire il tuo piano di controllo o i tuoi nodi Kubernetes.
+ [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)) è uno strumento open source che ti aiuta a interagire con i servizi AWS tramite comandi nella tua shell a riga di comando.
+ [Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) distribuisce automaticamente il traffico in entrata su più destinazioni, come istanze Amazon Elastic Compute Cloud ( EC2Amazon), contenitori e indirizzi IP, in una o più zone di disponibilità.
+ [eksctl](https://eksctl.io/) ti aiuta a creare cluster su Amazon EKS.
+ [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) consente di eseguire comandi contro i cluster Kubernetes.
+ [Docker](https://www.docker.com/) ti aiuta a creare, testare e distribuire applicazioni in pacchetti chiamati contenitori.

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

### Crea un cluster Amazon EKS utilizzando eksctl
<a name="create-an-amazon-eks-cluster-by-using-eksctl"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Crea un cluster Amazon EKS.  | Per creare un cluster Amazon EKS che utilizza due EC2 istanze Amazon t2.small come nodi, esegui il seguente comando:<pre>eksctl create cluster --name <your-cluster-name> --version <version-number> --nodes=1 --node-type=t2.small</pre>Il processo può richiedere dai 15 ai 20 minuti. [Dopo la creazione del cluster, la configurazione Kubernetes appropriata viene aggiunta al file kubeconfig.](https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html) Puoi utilizzare il `kubeconfig` file con per distribuire l'applicazione nei `kubectl`**** passaggi successivi. | Sviluppatore, amministratore di sistema | 
| Verifica il cluster Amazon EKS. | Per verificare che il cluster sia stato creato e che tu possa connetterti ad esso, esegui il `kubectl get nodes` comando. | Sviluppatore, amministratore di sistema | 

### Crea un repository Amazon ECR e invia l'immagine Docker.
<a name="create-an-amazon-ecr-repository-and-push-the-docker-image"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Crea un repository Amazon ECR. | Segui le istruzioni riportate nella sezione [Creazione di un repository privato](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) nella documentazione di Amazon ECR. | Sviluppatore, amministratore di sistema | 
| Crea un file XML POM. | Crea un `pom.xml` file basato sul codice del *file POM di esempio* nella sezione [Informazioni aggiuntive](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) di questo modello. | Sviluppatore, amministratore di sistema | 
| Crea un file sorgente. | Crea un file sorgente chiamato `HelloWorld.java` nel `src/main/java/eksExample` percorso in base al seguente esempio:<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>Assicuratevi di utilizzare la seguente struttura di cartelle:<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> |  | 
| Crea un Dockerfile. | Crea un file `Dockerfile` basato sul codice *Dockerfile di esempio* nella sezione [Informazioni aggiuntive](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) di questo modello. | Sviluppatore, amministratore di sistema | 
| Crea e invia l'immagine Docker. | Nella directory in cui desideri `Dockerfile` creare, taggare e inviare l'immagine ad Amazon ECR, esegui i seguenti comandi:<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>Modifica la regione AWS, il numero di account e i dettagli del repository nei comandi precedenti. Assicurati di annotare l'URL dell'immagine per un uso successivo.Un sistema macOS con un chip M1 ha problemi a creare un'immagine compatibile con Amazon EKS in esecuzione su una piattaforma. AMD64 Per risolvere questo problema, usa [docker buildx](https://docs.docker.com/engine/reference/commandline/buildx/) per creare un'immagine Docker che funzioni su Amazon EKS. |  | 

### Implementa i microservizi Java
<a name="deploy-the-java-microservices"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Crea un file di distribuzione.  | Crea un file YAML chiamato in `deployment.yaml` base al codice del *file di distribuzione di esempio* nella sezione [Informazioni aggiuntive](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) di questo modello.Usa l'URL dell'immagine che hai copiato in precedenza come percorso del file di immagine per il repository Amazon ECR. | Sviluppatore, amministratore di sistema | 
| Implementa i microservizi Java sul cluster Amazon EKS.  | Per creare una distribuzione nel tuo cluster Amazon EKS, esegui il `kubectl apply -f deployment.yaml` comando. | Sviluppatore, amministratore di sistema | 
| Verifica lo stato dei pod. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer.html) | Sviluppatore, amministratore di sistema | 
| Crea un servizio. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer.html) | Sviluppatore, amministratore di sistema | 
| Installa il componente aggiuntivo AWS Load Balancer Controller. | Segui le istruzioni contenute nell'[installazione del componente aggiuntivo AWS Load Balancer Controller](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html) nella documentazione di Amazon EKS.È necessario che il componente aggiuntivo sia installato per creare un Application Load Balancer o un Network Load Balancer per un servizio Kubernetes. | Sviluppatore, amministratore di sistema | 
| Crea una risorsa di ingresso. | Crea un file YAML chiamato in `ingress.yaml` base al codice del *file di risorse di ingresso di esempio* nella sezione [Informazioni aggiuntive](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) di questo modello. | Sviluppatore, amministratore di sistema | 
| Crea un Application Load Balancer. | Per distribuire la risorsa in ingresso e creare un Application Load Balancer, esegui il comando. `kubectl apply -f ingress.yaml` | Sviluppatore, amministratore di sistema | 

### Eseguire il test dell’applicazione
<a name="test-the-application"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Testa e verifica l'applicazione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer.html) | Sviluppatore, amministratore di sistema | 

## Risorse correlate
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-resources"></a>
+ [Creazione di un repository privato](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) (documentazione Amazon ECR)
+ [Inviare un'immagine Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) (documentazione Amazon ECR)
+ [Controller di ingresso (Amazon EKS](https://www.eksworkshop.com/beginner/130_exposing-service/ingress_controller_alb/) Workshop)
+ Compilazioni [Docker (Docker](https://docs.docker.com/engine/reference/commandline/buildx/) docs)

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

**Esempio di file POM**

```
<?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>
```

**Esempio di 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"]
```

**Esempio di file di distribuzione**

```
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
```

**File di servizio di esempio**

```
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
```

**Esempio di file di risorse di ingresso**

```
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
```