As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Implante um exemplo de microsserviço Java no Amazon EKS e exponha o microsserviço usando um 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*

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

Esse padrão descreve como implantar um microsserviço Java de exemplo como uma aplicação em contêiner no Amazon Elastic Kubernetes Service (Amazon EKS) usando o utilitário de linha de comando `eksctl` e o Amazon Elastic Container Registry (Amazon ECR). Você pode usar um Application Load Balancer para balancear a carga do tráfego do aplicativo.

## Pré-requisitos e limitações
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-prereqs"></a>

**Pré-requisitos **
+ Uma conta AWS ativa
+ AWS Command Line Interface (AWS CLI) versão 1.7 ou mais recente, instalada e configurada no macOS, Linux ou Windows
+ Um [daemon do Docker](https://docs.docker.com/config/daemon/) em execução
+ O utilitário de linha de comando `eksctl`, instalado e configurado no macOS, Linux ou Windows (para obter mais informações, consulte [Conceitos básicos do Amazon EKS – eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) na documentação do Amazon EKS.)
+ O utilitário de linha de comando `kubectl`, instalado e configurado no macOS, Linux ou Windows (para obter mais informações, consulte [Instalar ou atualizar kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) na documentação do Amazon EKS.)

**Limitações**
+ Esse padrão não abrange a instalação de um certificado SSL para o Application Load Balancer.

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

**Pilha de tecnologias de destino**
+ Amazon ECR
+ Amazon EKS
+ Elastic Load Balancing

**Arquitetura de destino**

 O diagrama a seguir mostra uma arquitetura para a conteinerização de um microsserviço Java no Amazon EKS.

![\[Um microsserviço Java implantado como uma aplicação em contêineres no Amazon EKS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/e1dd8ab0-9e1e-4d2b-b7af-89d3e583e57c/images/aaca4fd9-5aaa-4df5-aebd-02a2ed881c3b.png)


## Ferramentas
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-tools"></a>
+ O [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) é um serviço gerenciado de registro de imagens de contêineres seguro, escalável e confiável.
+ O [Amazon Elastic Kubernetes Service (Amazon EKS)](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) ajuda você a executar o Kubernetes na AWS sem precisar instalar e manter seus próprios nós ou ambiente de gerenciamento do Kubernetes.
+ A ‭[AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)‭ é uma ferramenta de código aberto que permite que você interaja com serviços da AWS usando comandos no shell da linha de comando.
+ O [Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) distribui automaticamente seu tráfego de entrada entre vários destinos, como instâncias, contêineres e endereços IP do EC2 Amazon Elastic Compute Cloud (Amazon), em uma ou mais zonas de disponibilidade.
+ O [eksctl](https://eksctl.io/) ajuda você a criar clusters no Amazon EKS.
+ O [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) possibilita a execução de comandos nos clusters do Kubernetes.
+ O [Docker](https://www.docker.com/) ajuda você a criar, testar e entregar aplicativos em pacotes chamados contêineres.

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

### Crie de um cluster do Amazon EKS usando eksctl
<a name="create-an-amazon-eks-cluster-by-using-eksctl"></a>


| Tarefa | Description | Habilidades necessárias | 
| --- | --- | --- | 
| Crie um cluster do Amazon EKS.  | Para criar um cluster Amazon EKS que usa duas EC2 instâncias t2.small da Amazon como nós, execute o seguinte comando:<pre>eksctl create cluster --name <your-cluster-name> --version <version-number> --nodes=1 --node-type=t2.small</pre>O processo pode demorar entre 15 e 20 minutos. Depois que o cluster é criado, a configuração apropriada do Kubernetes é adicionada ao seu arquivo [kubeconfig](https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html). Você pode usar o arquivo `kubeconfig` com `kubectl`** **para implantar o aplicativo em etapas posteriores. | Desenvolvedor, administrador do sistema | 
| Verifique o cluster do Amazon EKS. | Para verificar se o cluster foi criado e se você pode se conectar a ele, execute o comando `kubectl get nodes`. | Desenvolvedor, administrador do sistema | 

### Crie um repositório Amazon ECR e envie a imagem do Docker.
<a name="create-an-amazon-ecr-repository-and-push-the-docker-image"></a>


| Tarefa | Description | Habilidades necessárias | 
| --- | --- | --- | 
| Crie um repositório do Amazon ECR. | Siga as instruções em [Criar um repositório privado](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) na documentação do Amazon ECR. | Desenvolvedor, administrador do sistema | 
| Crie um arquivo XML POM. | Crie um arquivo `pom.xml` com base no código de *arquivo POM de exemplo* na seção [Additional information](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) desse padrão. | Desenvolvedor, administrador do sistema | 
| Criar um arquivo de origem. | Crie um arquivo de origem chamado `HelloWorld.java` no caminho `src/main/java/eksExample` com base no exemplo a seguir:<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>Certifique-se de usar a seguinte estrutura de diretório:<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> |  | 
| Crie um Dockerfile. | Crie um `Dockerfile` com base no código de *Exemplo de Dockerfile* na seção [Informações adicionais](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) desse padrão. | Desenvolvedor, administrador do sistema | 
| Compilar e enviar por push uma imagem do Docker | No diretório em que você deseja criar, marcar e enviar a imagem `Dockerfile` para o Amazon ECR, execute os seguintes comandos:<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>Modifique a região da AWS, o número da conta e os detalhes do repositório nos comandos anteriores. Certifique-se de anotar a URL da imagem para uso posterior.Um sistema macOS com um chip M1 tem problemas ao criar uma imagem compatível com o Amazon EKS executado em uma plataforma. AMD64 Para resolver esse problema, use o [docker buildx](https://docs.docker.com/engine/reference/commandline/buildx/) para criar uma imagem do Docker que funcione no Amazon EKS. |  | 

### Implemente os microsserviços Java
<a name="deploy-the-java-microservices"></a>


| Tarefa | Description | Habilidades necessárias | 
| --- | --- | --- | 
| Crie um arquivo de implantação.  | Crie um arquivo YAML chamado `deployment.yaml` com base no código de *arquivo de exemplo de implantação* na seção [Informações adicionais](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) desse padrão.Use o URL da imagem que você copiou anteriormente como o caminho do arquivo de imagem para o repositório do Amazon ECR. | Desenvolvedor, administrador do sistema | 
| Implante os microsserviços Java no cluster Amazon EKS.  | Para criar uma implantação em seu cluster Amazon EKS, execute o comando `kubectl apply -f deployment.yaml`. | Desenvolvedor, administrador do sistema | 
| Verifique o status dos pods. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer.html) | Desenvolvedor, administrador do sistema | 
| Crie um serviço. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer.html) | Desenvolvedor, administrador do sistema | 
| Instale o complemento Load Balancer Controller da AWS. | Siga as instruções de [Instalar o complemento AWS Load Balancer Controller](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html) na documentação do Amazon EKS.É necessário ter o complemento instalado para criar um Application Load Balancer ou Network Load Balancer para um serviço do Kubernetes. | Desenvolvedor, administrador do sistema | 
| Crie um recurso de entrada. | Crie um arquivo YAML chamado `ingress.yaml` com base no código de *arquivo de exemplo de recurso de ingresso* na seção [Informações adicionais](#deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional) desse padrão. | Desenvolvedor, administrador do sistema | 
| Criar um Application Load Balancer. | Para implantar o recurso de entrada e criar um Application Load Balancer, execute o comando `kubectl apply -f ingress.yaml`. | Desenvolvedor, administrador do sistema | 

### Teste a aplicação
<a name="test-the-application"></a>


| Tarefa | Description | Habilidades necessárias | 
| --- | --- | --- | 
| Teste e verifique a aplicação. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer.html) | Desenvolvedor, administrador do sistema | 

## Recursos relacionados
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-resources"></a>
+ [Criar um repositório privado](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) (documentação do Amazon ECR)
+ [Enviar por push uma imagem do Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) (documentação do Amazon ECR)
+ [Controladores de entrada](https://www.eksworkshop.com/beginner/130_exposing-service/ingress_controller_alb/) (Amazon EKS Workshop)
+ [Docker buildx](https://docs.docker.com/engine/reference/commandline/buildx/) (documentos do Docker)

## Mais informações
<a name="deploy-a-sample-java-microservice-on-amazon-eks-and-expose-the-microservice-using-an-application-load-balancer-additional"></a>

**Example POM file**

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

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

**Example deployment file**

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

**Example service file**

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

**Example ingress resource file**

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