A AtSea Shop é um exemplo de aplicativo de vitrine que pode ser implantado em diferentes sistemas operacionais e pode ser personalizado tanto para o seu desenvolvimento empresarial quanto para os ambientes operacionais. Discuti a arquitetura do aplicativo em um outro artigo. Hoje, abordarei como configurar seu ambiente de desenvolvimento para depurar o backend Java REST que é executado em um contêiner.

Criando o aplicativo REST

Eu usei o framework Spring Boot para desenvolver rapidamente o backend REST que gerencia os painéis de produtos, clientes e pedidos usados na AtSea Shop. O aplicativo aproveita o servidor de aplicativos embutido da Spring Boot, o suporte para interfaces REST e a capacidade de definir múltiplas fontes de dados. Como foi escrito em Java, é agnóstico para o sistema operacional básico e é executado em contêineres Windows ou Linux. Isso permite que os desenvolvedores construam contra uma arquitetura heterogênea.

Configuração do projeto

O projeto AtSea usa compilações em vários estágios, um novo recurso Docker, que me permite usar várias imagens para criar uma única imagem do Docker que inclui todos os componentes necessários para o aplicativo. A compilação multi estágio usa um contêiner Maven para criar o arquivo o jar do aplicativo. O arquivo jar é, então, copiado para uma imagem do Java Development Kit. Isso torna uma imagem mais compacta e eficiente porque o Maven não está incluído no aplicativo. Da mesma forma, o cliente frontal do store React é construído em uma imagem de Node e o aplicativo de compilação também é adicionado à imagem final do aplicativo.

Usei o Eclipse para escrever o aplicativo AtSea. Se você quiser informações sobre como configurar IntelliJ ou Netbeans para depuração remota, você pode verificar o Repositório Docker Labs. Você também pode verificar o código no GitHub do AtSea.

Eu criei o aplicativo clonando o repositório e importei o projeto para o Eclipse configurando o Diretório Raiz para o projeto e clicando em Concluir

 File > Import > Maven > Existing Maven Projects

Como usei o Spring Boot, aproveitei Spring-Devtools para fazer depuração remota no aplicativo. Eu tive que adicionar a dependência Spring Boot-devtools ao arquivo pom.xml.

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-devtools</artifactId>
</dependency>

Observe que as ferramentas do desenvolvedor são automaticamente desativadas quando o aplicativo é totalmente empacotado como um jar. Para garantir que os devtools estejam disponíveis durante o desenvolvimento, defini a configuração <excludeDevtools> como false no plugin de compilação spring-boot-maven:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludeDevtools>false</excludeDevtools>
            </configuration>
        </plugin>
    </plugins>
</build>

Este exemplo usa um arquivo Docker Compose que cria uma compilação simplificada dos contêineres especificamente necessários para desenvolvimento e depuração.

 version: "3.1"

services:
  database:
    build: 
       context: ./database
    image: atsea_db
    environment:
      POSTGRES_USER: gordonuser
      POSTGRES_DB: atsea
    ports:
      - "5432:5432" 
    networks:
      - back-tier
    secrets:
      - postgres_password

  appserver:
    build:
       context: .
       dockerfile: app/Dockerfile-dev
    image: atsea_app
    ports:
      - "8080:8080"
      - "5005:5005"
    networks:
      - front-tier
      - back-tier
    secrets:
      - postgres_password

secrets:
  postgres_password:
    file: ./devsecrets/postgres_password
    
networks:
  front-tier:
  back-tier:
  payment:
    driver: overlay

O arquivo Compose usa segredos para fornecer senhas e outras informações confidenciais, como certificados – sem depender de variáveis ambientais. Embora o exemplo use PostgreSQL, o aplicativo pode usar segredos para se conectar a qualquer banco de dados definido como fonte de dados Spring Boot. De JpaConfiguration.java:

 public DataSourceProperties dataSourceProperties() {
        DataSourceProperties dataSourceProperties = new DataSourceProperties();

    // Set password to connect to database using Docker secrets.
    try(BufferedReader br = new BufferedReader(new FileReader("/run/secrets/postgres_password"))) {
        StringBuilder sb = new StringBuilder();
        String line = br.readLine();
        while (line != null) {
            sb.append(line);
            sb.append(System.lineSeparator());
            line = br.readLine();
        }
         dataSourceProperties.setDataPassword(sb.toString());
     } catch (IOException e) {
        System.err.println("Could not successfully load DB password file");
     }
    return dataSourceProperties;
}

Observe também que o servidor de aplicativos abre a porta 5005 para depuração remota e essa compilação chama o arquivo Dockerfile-dev para criar um contêiner que tenha depuração remota ativada. Isso é definido no Ponto de entrada que especifica transporte e endereço para o depurador.

ENTRYPOINT ["java", 

"-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005","-jar", 

"/app/AtSea-0.0.1-SNAPSHOT.jar"]

Depuração remota

Para iniciar a depuração remota no aplicativo, execute compose usando o arquivo docker-compose-dev.yml.

docker-compose -f docker-compose-dev.yml up --build

O Docker irá construir as imagens e iniciar o banco de dados do AtSea e os contêineres do servidor de aplicativos. No entanto, o aplicativo não será totalmente carregado até que o depurador remoto do Eclipse se anexe ao aplicativo. Para iniciar a depuração remota, clique em Executar> Configurações de Depuração…

Selecione Remote Java Application e, então, pressione o novo botão para criar uma configuração. No painel Configurações de Depuração, você atribui um nome à configuração, seleciona o projeto AtSea e define as propriedades de conexão para o host e a porta para 5005. Clique em Aplicar> Depurar.

O servidor de aplicativos será iniciado.

appserver_1|2017-05-09 03:22:23.095 INFO 1 --- [main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)

appserver_1|2017-05-09 03:22:23.118 INFO 1 --- [main] com.docker.atsea.AtSeaApp                : Started AtSeaApp in 38.923 seconds (JVM running for 109.984)

Para testar a depuração remota, defina um ponto de interrupção no ProductController.java onde ele retorna uma lista de produtos.

Você pode testá-lo usando curl ou sua ferramenta preferida para fazer solicitações HTTP:

curl -H "Content-Type: application/json" -X GET  http://localhost:8080/api/product/

O Eclipse irá mudar para a perspectiva de depuração, onde você pode passar pelo código.

O exemplo da AtSea Shop mostra como é fácil usar contêineres como parte do seu ambiente de desenvolvimento normal usando ferramentas com as quais você e sua equipe já estejam familiarizadas. Baixe o aplicativo para experimentar o desenvolvimento com contêineres ou use-o como base para o seu próprio aplicativo Spring Boot REST.

 

***

Este artigo é do Docker Core Engineering. A tradução foi feita pela Redação iMasters com autorização, e você pode acompanhar o artigo em inglês no link: https://blog.docker.com/2017/05/spring-boot-development-docker/