Forem: Marcus Paulo

Tutorial: Publish a Quarkus application in Kubernetes, Minikube and Dockerhub

Marcus Paulo — Sat, 10 Apr 2021 00:51:26 +0000

Notes

This is my first English post, then please give me your feedback, and suggestion to correct any mistakes.

Introduction

The article purpose to create a simple application in Quakus and publish in Minikube (Kubernetes for the local test) and finally publish the image Docker to in Dockerhub.

For more information on these technologies: Kubernetes (K8S), Docker, Minikube, Kubectl e do Quarkus, please visit these sites:

Docker: https://www.docker.com/

Kubernetes: https://kubernetes.io/pt/

Minikube: https://minikube.sigs.k8s.io/docs/start/

Minikube (Kubernetes): https://kubernetes.io/pt/docs/tutorials/kubernetes-basics/create-cluster/cluster-intro/

Quarkus: https://quarkus.io/

Minikube is local Kubernetes, focusing on making it easy to learn and develop for Kubernetes. It is not recommending to production environment.

Prerequisites

Install Docker: https://docs.docker.com/engine/install/
Install Kubernetes: https://kubernetes.io/pt/docs/setup/
Install Kubeclt: https://kubernetes.io/docs/tasks/tools/
Install Minikube: https://minikube.sigs.k8s.io/docs/start/
Install Open JDK 11+: https://openjdk.java.net/install/

Let’s go! We will create a new simple Quarkus application.

Create a simple Quarkus application by command line

mvn io.quarkus:quarkus-maven-plugin:1.13.0.Final:create \\\\    -DprojectGroupId=br.com.mp \\\\    -DprojectArtifactId=kubernetes-quarkus \\\\    -DclassName="br.com.mp.kubernetes.quarkus.rest.GreetingResource" \\\\    -Dpath="/hello" \\\\    -Dextensions="resteasy,kubernetes,jib"

Access the project folder

cd kubernetes-quarkus

In the next step, let’s go to test the project

mvn quarkus:dev

Result in terminal (console)

Running Quarkus application by command line

mvn quarkus:add-extension -Dextensions="quarkus-minikube"

Or you can insert in pom.xml

<dependency>  <groupId>io.quarkus</groupId>  <artifactId>quarkus-minikube</artifactId></dependency>

It is possible to create Quarkus application by command line, adding Minikube extensions.

Creating a local Container Registry in Minikube

It is necessary to set the environment variable with “eval” command.

eval $(minikube -p minikube docker-env)

Create Docker image with Quarkus by command line

Next step, create a maven package with Quarkus parameter to build a container image.

mvn package -Dquarkus.container-image.build=true

Kubernetes and Minikube manifest create

After execute the last command, maven and Quarkus will create the manifest files, located in the folder “/target/kubernetes”, as you see in the image below.

List of all docker images

//List all docker imagesdocker image ls

[output]REPOSITORY                        TAG              IMAGE ID       CREATED         SIZEmarcus/kubernetes-quarkus-teste   1.0.0-SNAPSHOT   e574987218c4   3 minutes ago   199MB

In the next step, we need to apply Minikube manifest to publish in Minikube Kubernetes

kubectl apply -f target/kubernetes/minikube.yml

[output]service/kubernetes-quarkus-teste createddeployment.apps/kubernetes-quarkus-teste created

After a few seconds or minutes, the application is available on Minikube,

Pods are the smallest, most basic deployable objects in Kubernetes (https://cloud.google.com/kubernetes-engine/docs/concepts/pod)

List of all pods

kubectl get po

[output]NAME                                        READY   STATUS    RESTARTS   AGEkubernetes-quarkus-teste-54db4f8df8-gf7nf   1/1     Running   0          6m52s

Access the application at the local machine

To access on the local machine, it is required to redirect Minikube address to localhost, type this command. (Each Pod there is a unique name)

kubectl port-forward pod/kubernetes-quarkus-teste-54db4f8df8-gf7nf 8080:8080

[output]Forwarding from 127.0.0.1:8080 -> 8080Forwarding from [::1]:8080 -> 8080Handling connection for 8080

Access application in browser

Open your browser and insert this address:[http://localhost:8080](http://localhost:8080)

Publish the image to Dockerhub

From now, we are sending our docker image to Dockerhub, with maven command and Quarkus parameter (container image).

mvn clean package -Dquarkus.container-image.push=true

In my case, it happened this error

Caused by: com.google.cloud.tools.jib.api.RegistryUnauthorizedException:Unauthorized for registry-1.docker.io/marcus/kubernetes-quarkus-teste[ERROR]         at com.google.cloud.tools.jib.registry.RegistryEndpointCaller.call(RegistryEndpointCaller.java:164)[ERROR]

For fix this problem, please follow these steps:

1 — Type this command to login on Dockerhub services

docker login

2 — The local Docker image was created with username machine, in my case is marcus/kubernetes-quarkus, but the correct Dockerhub username is marcuspaulo.

Inside the Quarkus project, search application.properties file and insert the line above (with your Dockerhub username)

quarkus.container-image.group=marcuspaulo

Publish in the Dockerhub

mvn clean package -Dquarkus.container-image.push=true

Now, open your browser and access this address: https://hub.docker.com/repositories

I hope that you enjoy this tutorial. Thanks for your attention. Please like and share this post. See you soon.

Source code

https://github.com/marcuspaulo/kubernetes-quarkus

References

https://quarkus.io/guides/container-image#quarkus-container-image_quarkus.container-image.registry

https://quarkus.io/guides/deploying-to-kubernetes

https://quarkus.io/guides/kubernetes-client

https://minikube.sigs.k8s.io/docs/handbook/registry/

https://haralduebele.blog/2020/04/03/deploy-your-quarkus-applications-on-kubernetes-almost-automatically/

https://cloud.google.com/kubernetes-engine/docs/concepts/pod

Tutorial: Disponibilizando uma aplicação Quarkus no Kubernetes utilizando o Minikube e/ou DockerHub

Marcus Paulo — Fri, 09 Apr 2021 14:28:27 +0000

Introdução

O objetivo deste artigo é criar uma aplicação simples no Quarkus e em seguida mostrar como disponibilizar esta aplicação no Minikube (Kubernetes para testes na máquina local) e em seguida, como podemos enviar a imagem gerada para o repositório de imagens do Docker, que é o Dockerhub.

Para saber mais sobre o Kubernetes (K8S), Docker, Minikube, Kubectl e do Quarkus, eu recomendo as seguintes leituras:

Leituras adicionais

Site oficial do Docker: https://www.docker.com/

Site oficial do Kubernetes: https://kubernetes.io/pt/

Site oficial do Minikube: https://minikube.sigs.k8s.io/docs/start/

Minikube (Kubernetes): https://kubernetes.io/pt/docs/tutorials/kubernetes-basics/create-cluster/cluster-intro/

Site oficial do Quarkus: https://quarkus.io/

Publicações:

Tutorial: Quarkus do Zero até o Deploy no Heroku, utilizando Quarkus Java + REST + CDI + Panache, Hibernate com Postgres + Postman LinkedIn | Medium

Tutorial: Criando um CRUD utilizando Quarkus Java + REST + CDI + Panache, Hibernate com Postgres (Docker) + Postman — LinkedIn | Medium

- Tutorial: Quarkus — Simplificando o Hibernate utilizando Panache — criando uma aplicação simples utilizando Quarkus Java + REST + CDI + Panache — Linkedin | Medium

Atenção: O Minikube não deve ser utilizado em ambiente de produção.

Pré-Requisitos para esse tutorial

Instalar o Docker: https://docs.docker.com/engine/install/
Instalar o Kubernetes: https://kubernetes.io/pt/docs/setup/
Instalar o Kubeclt: https://kubernetes.io/docs/tasks/tools/
Instalação do Minikube: https://minikube.sigs.k8s.io/docs/start/
Open JDK 11+: https://openjdk.java.net/install/

Para iniciar, vamos criar uma simples aplicação no Quarkus, seguindo os passos abaixo:

Criar o projeto no Quarkus

mvn io.quarkus:quarkus-maven-plugin:1.13.0.Final:create \\    -DprojectGroupId=br.com.mp \\    -DprojectArtifactId=kubernetes-quarkus \\    -DclassName="br.com.mp.kubernetes.quarkus.rest.GreetingResource" \\    -Dpath="/hello" \\    -Dextensions="resteasy,kubernetes,jib"

Entre na pasta do projeto

cd kubernetes-quarkus

Testando o projeto

mvn quarkus:dev

Resultado

Executando uma aplicação Quarkus pela linha de comando

Adicionando a dependência do Minikube

mvn quarkus:add-extension -Dextensions="quarkus-minikube"

Ou diretamente no Pom.xml

<dependency>  <groupId>io.quarkus</groupId>  <artifactId>quarkus-minikube</artifactId></dependency>

A extensão do **quarkus-minikube** poderia ter sido adicionada na linha de comando da criação da aplicação.

Definindo o Minikube como Container Registry local

Para transformar o Minikube em um Container Registry local (um repositório de imagens), basta executar a linha abaixo no terminal.

eval $(minikube -p minikube docker-env)

Gerando a imagem do Docker

No próximo passo, será criada uma imagem Docker contendo a aplicação

mvn package -Dquarkus.container-image.build=true

Geração dos manifestos

Após a criação da imagem, será gerada os manifestos do Kubernetes e Minikube, na pasta “/target/kubernetes”, conforme a imagem abaixo:

Consultando a imagem gerada

Utilizando o docker para consultar a imagem que foi gerada

docker image ls

**[Resultado]**REPOSITORY                        TAG              IMAGE ID       CREATED         SIZEmarcus/kubernetes-quarkus-teste   1.0.0-SNAPSHOT   e574987218c4   3 minutes ago   199MB

Com a imagem já no Container Registry do Minikube, basta aplicar o manifesto do “minikube.yml”

Aplicando os manifestos do Minikube

kubectl apply -f target/kubernetes/minikube.yml

[Resultado]service/kubernetes-quarkus-teste createddeployment.apps/kubernetes-quarkus-teste created

Após alguns segundos, a aplicação estará disponível. No próximo comando, vamos listar os PODS.

Pod é a menor elemento do Kubernetes

Consultando os PODS

kubectl get po

[Resultado]NAME                                        READY   STATUS    RESTARTS   AGEkubernetes-quarkus-teste-54db4f8df8-gf7nf   1/1     Running   0          6m52s

Port-Forward para acessar na máquina local

Para acessar a aplicação, é necessário redirecionar o endereço do Minikube para a máquina local, através do comando Port-forward, para isso, copie o nome exato do seu pod, conforme demonstrado abaixo:

kubectl port-forward pod/kubernetes-quarkus-teste-54db4f8df8-gf7nf 8080:8080

[Resultado]Forwarding from 127.0.0.1:8080 -> 8080Forwarding from [::1]:8080 -> 8080Handling connection for 8080

Acessando a aplicação que foi disponibilizada pelo Minikube

Para acessar a aplicação, basta acessar o endereço: [http://localhost:8080/](http://localhost:8080/)

Enviando a imagem para o Dockerhub

A partir de agora, enviaremos a imagem docker da Aplicação para o repositório de imagens do Dockerhub.

Enviando a imagem para o Dockerhub

mvn clean package -Dquarkus.container-image.push=true

Erro ao enviar a imagem para o Dockerhub

Erro:

Caused by: com.google.cloud.tools.jib.api.RegistryUnauthorizedException: Unauthorized for registry-1.docker.io/marcus/kubernetes-quarkus-teste[ERROR]         at com.google.cloud.tools.jib.registry.RegistryEndpointCaller.call(RegistryEndpointCaller.java:164)[ERROR]

Caso ocorra o problema acima, é necessário realizar alguns procedimentos:

1 — No terminal, faça o login na sua conta do Dockerhub

docker login

2 — A imagem do Docker é criada de acordo com o nome do seu usuário do seu computador, no meu caso, a imagem foi criada como marcus/kubernetes-quarkus, porém, o meu usuário no Dockerhub é marcuspaulo.

Caso este seja o seu problema, basta definir o nome do seu usuário dentro das configurações no arquivo de propriedades (application.properties) do Quarkus, conforme a linha abaixo:

quarkus.container-image.group=marcuspaulo

Enviando para o Dockerhub

mvn clean package -Dquarkus.container-image.push=true

Consultando a imagem no Dockerhub, através do endereço: https://hub.docker.com/repositories

Espero que vocês tenham gostado, fico muito agradecido com o seu like e com o compartilhamento deste post, muito obrigado e até a próxima.

Código-fonte

https://github.com/marcuspaulo/kubernetes-quarkus

Referências

https://quarkus.io/guides/container-image#quarkus-container-image_quarkus.container-image.registry

https://quarkus.io/guides/deploying-to-kubernetes

https://quarkus.io/guides/kubernetes-client

https://minikube.sigs.k8s.io/docs/handbook/registry/

https://haralduebele.blog/2020/04/03/deploy-your-quarkus-applications-on-kubernetes-almost-automatically/

Simplificando o Hibernate utilizando Panache - criando uma aplicação simples utilizando Quarkus Java + REST + CDI + Panache

Marcus Paulo — Sun, 07 Feb 2021 03:03:05 +0000

Tutorial: Quarkus — Simplificando o Hibernate utilizando Panache — criando uma aplicação simples utilizando Quarkus Java + REST + CDI + Panache

Se inscreva no meu canal do Youtube, vários conteúdos para Desenvolvedores: https://www.youtube.com/channel/UCzoyY_hIVs53dQUeY4yVkhA

Introdução

Este artigo tem o objetivo de apresentar uma alternativa para simplificar a implementação da camada de persistência em uma aplicação Java. A maioria dos desenvolvedores Java conhecem a especificação JPA (Java Persistence API), que é uma interface comum para frameworks que trabalham com persistência de dados. Uma das implementações mais conhecidas é o Hibernate.

O Hibernate é um framework ORM (Mapeamento Objeto Relacional), que tem como objetivo, facilitar o mapeamento das tabelas, atributos e relacionamentos de um banco de dados para uma classe java.

No exemplo abaixo, podemos ver uma das formas para implementação de uma consulta para obter todos os carros de uma base de dados. No primeiro trecho de código, observamos a criação do EntityManagerFactory e em seguida a criação de um EntityManager, por fim, a consulta é criada retornando a lista de carros.

Como forma de comparação, veja no exemplo abaixo, a mesma implementação da recuperação da lista de todos os carros, utilizando o Panache.

O objetivo do Panache é simplificar a camada de persistência, principalmente das operações triviais.

No exemplo abaixo, podemos ver uma implementação para salvar um objeto carro no Banco de Dados. Explicando o código: O objeto carro é criado e “populado”, em seguida, ocorre a criação do EntityManagerFactory e do EntityManager. Antes de salvar o objeto é necessário abrir a conexão, salvar o carro e em seguida realizar o commit. Antes de terminar a execução do método é necessário fechar a conexão do banco de dados, através da instrução close();

* Exemplo adaptado da apostila da Caelum: https://www.caelum.com.br/apostila-java-web/uma-introducao-pratica-ao-jpa-com-hibernate/#trabalhando-com-os-objetos-o-entitymanager

No código-fonte abaixo, segue a implementação do salvar, utilizando o Panache.

Para utilizar os benefícios do Panache é necessário que a entidade estenda a classe PanacheBaseEntity. Dessa forma, a Classe que herda terá diversos métodos prontos para serem utilizados.

Voltando para o código, na primeira parte do código o Carro é instanciado e “populado”, em seguida, invoca o método estático (persist) da Classe Carro para salvar o objeto no banco de dados, para finalizar devolve o objeto para a requisição REST.

O Panache é responsável por gerenciar toda a transação, desde da abertura, commit e o fechamento da transação.

A ideia é facilitar a implementação, melhorando assim a produtividade, já que o código fica bem mais simples, se comparado a forma tradicional.

Métodos da classe PanacheEntityBase

Ao estender a classe PanacheEntityBase, a classe herda vários métodos úteis, como: Listar todos, salvar, atualizar, remover, buscar um objeto, retornar a quantidade de objetos de uma determinada tabela.

Listando carros com o nome Fusca, basta escrever: Car.find(“name”, “fusca”);

Listando carros ordenados por nome, basta escrever: Car.find("order by name”)

Métodos da classe PanacheEntityBase, para mais detalhes, veja o código-fonte

Abaixo a lista de métodos que são herdados, ao estender a classe PanacheEntityBase.

persist — Persiste uma entidade no banco de dados.
flush — Realiza o commit ou rollback de todas as transações pendentes
findById — Busca uma entidade por meio do ID
find — Lista os registros de uma entidade. (Parâmetros de Filtros e Sort são opcionais)
findAll — Lista todos os registros de uma entidade.
list — Atalho para find().list()
listAll — Atalho para findAll().list()
Count — Exibe a quantidade de registros de uma entidade. Você pode passar um parâmetro que é opcional.
deleteAll — Remover uma lista de objetos do banco de dados.
delete — Remove uma entidade, podendo utilizar uma Query (Opcional)

Parte prática — Hands-on (Tutorial passo a passo)

Para facilitar o entendimento do Framework Panache, será criado um projeto em Quarkus + Panache e um banco de dados em Postgres, mostrando os diversos cenários em que o Panache pode auxiliar o desenvolvedor.

Para mais detalhes do Quarkus, veja o meu artigo: https://www.linkedin.com/pulse/tutorial-criando-um-crud-utilizando-quarkus-java-rest-da-silva-melo/

Antes de iniciar o desenvolvimento da aplicação, é necessário atender os requisitos mínimos abaixo:

Requisitos mínimos:

Você vai precisar de uma IDE como por exemplo: IntelliJ IDEA, Eclipse, VSCode.
Instale a JDK 8 or 11+
Instale o Apache Maven 3.5.3+ ou o Gradle
Panache Entity
Docker
Escolha um cliente para conectar com o Banco de dados, exemplo: DBeaver, MySql Workbench, entre outros.
Cliente para realizar requisições REST: Postman ou o Insomnia.

Instruções Adicionais:

Instalação do Docker (Documentação oficial)
Instalando Docker no windows: (Youtube, ESR)
Instalando o Docker no Linux: (Youtube: LinuxTips)
Instalando o Docker no Mac: (Youtube: Wellington Rogati)

Escopo da aplicação

A partir de agora, vamos criar uma aplicação que será desenvolvida com o Quarkus, utilizando o Panache + Hibernate para persistência, CDI e JAX-RS para a API REST.

A aplicação consiste em realizar Cadastro, Alteração, Atualização, Listagem, Paginação, Consultas Personalizadas e entre outras funcionalidades do Panache para gerenciar os Carros cadastrados no banco de dados.

// Criação do projeto em Quarkus

mvn io.quarkus:quarkus-maven-plugin:1.0.1.Final:create \

-DprojectGroupId=br.com.car \

-DprojectArtifactId=quarkus-panache-car \

-DclassName="br.com.car.resource.CarResource" \

-Dpath="/cars"

Em seguida, vamos executar o projeto, através do comando:

mvn compile quarkus:dev

No navegador, acesse o endereço: http://localhost:8080

Configurando o Panache no Projeto

Adiciona as configurações abaixo no arquivo application.properties, na pasta resource na raiz do projeto.

configure your datasource

quarkus.datasource.url = jdbc:postgresql://localhost:5433/quarkus-panache-car

quarkus.datasource.driver = org.postgresql.Driver

quarkus.datasource.username = postgres

quarkus.datasource.password = postgres

drop and create the database at startup (use `update` to only update the schema)

quarkus.hibernate-orm.database.generation = drop-and-create

Adicione as dependências do Panache no pom.xml.

io.quarkus

quarkus-hibernate-orm-panache

io.quarkus

quarkus-jdbc-postgresql

io.quarkus

quarkus-resteasy-jsonb

Observação: Para criar a massa de dados no início da aplicação, basta adicionar o arquivo import.sql, dentro da pasta resource do projeto.

Executando uma instância do Postgresql no Docker

Para armazenar as informações, iniciaremos uma instância do Postgresql, utilizando o Docker, para isso, é necessário ter o Docker instalado e então executar o comando listado abaixo:

Criando uma instância do Postgressql através do Docker

docker run --name postgres-car -e "POSTGRES_PASSWORD=postgres" -p 5433:5432 -v ~/developer/PostgreSQL:/var/lib/postgresql/data -d postgres

Entidade Car (o modelo da aplicação)

@Entity

public class Car extends PanacheEntityBase {

@Id  
@GeneratedValue(strategy = GenerationType.IDENTITY)  
private Long id;

private String brand;

private String name;

@Column(name="model_year")  
private LocalDate modelYear;

@Column(name="created_date_time")  
private LocalDateTime createdDateTime;

@Column(name="is_available_sale")  
private Boolean isAvailableSale;

private BigDecimal price;

// Omitido

Observação: O atributo Id (Chave Primária) é opcional, quando a classe estende o PanacheEntityBase

Testando a aplicação

Para fins didáticos, vamos separa os testes em duas partes, a primeira será utilizando os métodos do PanacheEntityBase, dentro da classe Resource (EndPoint). A segunda parte, será utilizando uma classe Repository + Resource(EndPoint).

Observação 1: Outra forma seria criar uma camada de Serviço (Service) para “chamar” os métodos de uma classe DAO ou de um Repositório.

Observação 2: Sinta-se a vontade para definir o melhor padrão de sufixos de nomes, exemplo: Camada do EndPoint (API/Rest): (Controller, EndPoint, …). Camada de Negócio: (Controller, Manager, Business, ….) e assim por diante.

Listando todos os Carros (Versão 1)

Para acessar a lista de todos os carros, basta chamar o método estático da classe Car, que é herdado a partir do PanacheEntityBase.

@path("/cars")

@Produces(MediaType.APPLICATION_JSON)

public class CarResource {

@GET  
public List<Car> listAll() {  
    return Car.listAll();

}

Resultado no Postman

Outro forma é implementar na classe de sufixo Repository ou na classe DAO. A implementação será utilizando a classe DAO ou Repository, bastando implementar PanacheRepository, conforme o exemplo abaixo:

@ApplicationScoped

public class CarRepository implements PanacheRepository {

public List<Car> listAll() {  
    return listAll();  
}

// omitido

A implementação na classe CarV2Resource (EndPoint Rest):

@path("/cars/v2")

@Produces(MediaType.APPLICATION_JSON)

public class CarV2Resource {

@Inject


private CarRepository carRepository;

@GET


public List<Car> listAll() {


    return carRepository.listAll();

}

Postman — Listar todos os veículos na versão 2 da API

O resultado é exatamente igual, quando implementado diretamente na classe do Endpoint da API.

Criando um veículo (Versão 1)

Criando um veículo, invocando o método estático da Classe Car, dentro da CarResource(EndPoint), conforme exemplo abaixo:

A anotação @Transactional é responsável por gerenciar a transação efetuando um commit ou um rollback na transação, caso seja necessário;

@post

@Transactional

public Response create(Car car) {

Car.persist(car);

return Response.ok(car).status(Response.Status.CREATED).build();

}

Evoluindo a criação de um veículo

No endpoint CarV2Resource, basta chamar o método save, que está implementado no PanacheRepository.

Classe: CarV2Resource.java

@post

public Response create(Car car) {

Car carEntity = carRepository.save(car);

return Response.ok(car).status(Response.Status.CREATED).build();

}

Postman — Resultado da inclusão de um veículo

Listando os carros por ano

// CarResource.java

@GET

@path("/listCarsByYear")

public List listCarsByYear(@QueryParam("year") int year) {

return Car.find("year(modelYear) = :year", Parameters.with("year",

year)).list();

}

Na versão 2, a implementação utiliza o carRepository e chama o método listCarsByYear(year);

// CarV2Resource.java

@GET

@path("/listCarsByYear")

public List listCarsByYear(@QueryParam("year") int year) {

return carRepository.listCarsByYear(year);

}

Implementação da lógica de pesquisa de carro por ano, na classe CarRepository.java

//CarRepository.java

public List listCarsByYear(int year) {

return find("year(modelYear) = :year", Parameters.with("year", year)).list();

}

Postman — Resultado da busca de veículos por ano

Outros métodos:

Listar todos os carros que estão disponíveis para venda

Listar todos os veículos ordenados por Nome e Marca.

Listar todos os veículos passando o ano como Parâmetro

Retornar a quantidade de veículos cadastrados

Listar veículos com paginação

Atualizar veículo

Conclusão

Espero que vocês tenham gostado, sinta-se à vontade para sugerir, criticar ou elogiar. Um grande abraço e até a próxima.

Código-Fonte

O código-fonte está disponível no endereço: https://github.com/marcuspaulo/quarkus-panache-car

Tutorial: Criando um CRUD utilizando Quarkus Java + REST + CDI + Panache, Hibernate com Postgres (Docker) + Postman

Marcus Paulo — Mon, 01 Feb 2021 12:28:33 +0000

Tutorial: Criando um CRUD utilizando Quarkus Java + REST + CDI + Panache, Hibernate com Postgres (Docker) + Postman

Se inscreva no meu canal do Youtube, vários conteúdos para Desenvolvedores: https://www.youtube.com/channel/UCzoyY_hIVs53dQUeY4yVkhA

Introdução

Os programadores de Java estão “cansados” de ouvir as seguintes expressões: “Java é lento!”, “O pacote do java é grande”, “O tempo de inicialização é lento!”. Como uma forma de resolver isso, a Red Hat lançou o Quarkus, um framework Java nativo do Kubernetes feito sob medida para o GraalVM e OpenJDK HotSpot. O Quarkus visa tornar o java uma plataforma líder em ambientes serverless e Kubernetes, oferecendo aos desenvolvedores um modelo unificado de programação reativa e imperativa.

O QuarkusIO, promete entregar pacotes menores, com um tempo de inicialização extremanente rápido, menor consumo de memória, desde que combinado com a GraalVM, O Quarkus vai realizar a compilação Ahead-of-time(AOT). Baseada nos melhores padrões, plataforma integrada, baixo consumo de processamento e tempo de inicialização é incrivelmente rápido, em milisegundos, Quarkus permite o uso do Java em ambientes serverless, suportando um ambiente responsivo e escalável.

Na imagem abaixo, podemos ver a comparação do consumo e memória e o tempo de inicialização + tempo da resposta da primeira requisição, podemos perceber que o Quarkus + OpenJDK + GraalVM, consomem menos memória e iniciam mais rapidamente, do que a o Quarkus + OpenJDK e um framework equivalente de mercado.

Um grande diferencial do Quarkus é que ele suporta as principais especificações, ou seja, você, não precisa aprender nada de novo. Por exemplo, você pode utilizar o CDI e JAX-RS, também é possível suportar as extensões como: Hibernate, Kafka, OpenShift, Kubernetes. Na era do cloud, no qual containers, Kubernetes, microservices, functions-as-a-service (Faas), e aplicações nativas para o cloud estão apresentando altos níveis de produtividade e eficiência, o Quarkus surge com uma alternativa muito interessante.

Antes de continuar o post, gostaria de compartilhar a apresentação que fiz nesse ano.

Apresentação no Evento Brasília Dev Festival 2019

Em Setembro de 2019, palestrei no evento Brasília Dev Festival, realizado em Brasília, foi um evento recheado de muito conhecimento e network, a apresentação está disponível abaixo:

Parte prática — Hands-on (Tutorial passo a passo)

Antes de iniciar o desenvolvimento da aplicação, é necessário atender os requisitos mínimos abaixo:

Requisitos mínimos:

Você vai precisar de uma IDE como por exemplo: IntelliJ IDEA, Eclipse, VSCode.
Instale a JDK 8 or 11+
Instale o Apache Maven 3.5.3+ ou o Gradle
(Opcional) — Você pode baixar o GraalVM 19.2.1 para compilar nativamente sua aplicação.
Panache Entity (Possível artigo futuro)
Docker
Escolha um cliente para conectar com o Banco de dados, exemplo: DBeaver, PGAdmin, Postico (Mac)
Cliente para realizar requisições REST: Postman ou o Insomnia.

Instruções Adicionais:

Instalação do Docker (Documentação oficial)
Instalando Docker no windows: (Youtube, ESR)
Instalando o Docker no Linux: (Youtube: LinuxTips)
Instalando o Docker no Mac: (Youtube: Wellington Rogati)

Escopo da aplicação

A partir de agora, vamos criar uma aplicação que será desenvolvida com o Quarkus, utilizando o Panache + Hibernate para persistência, vamos utilizar o CDI para Injeção de Dependência e JAX-RS para a API REST.

Vamos criar uma API para Listar, Cadastrar, Editar e Excluir alimentos.

O Quarkus possui um Archetype para criação da aplicação de forma fácil, basta executar o comando abaixo:

Sugestão: verifique a última versão no site oficial do Quarkus.io.

mvn io.quarkus:quarkus-maven-plugin:1.11.1.Final:create \

-DprojectGroupId=br.com.food \

-DprojectArtifactId=quarkus-food \

-DclassName="br.com.food.resource.FoodResource" \

-Dpath="/food"

$ cd quarkus-food

Vamos entender o que cada trecho significa:

Plugin do Maven para criação do Projeto no Quarkus

$ mvn io.quarkus:quarkus-maven-plugin:1.11.1.Final:create

Definição do pacote do projeto

-DprojectGroupId=br.com.food

Definição do Nome do Projeto

-DprojectArtifactId=quarkus-food

Definindo o caminho da classe Rest (inicial)

-DclassName="br.com.food.resource.FoodResource"

Definição da URI, final do endereço para acessar no navegador

-Dpath="/food

O Quarkus disponibiliza um site chamado Quarkus.code.io, onde é posísvel configurar o projeto de uma forma mais visual, vale a pena conferir, segue o link: https://code.quarkus.io/

Site: code.quarkus.io

Criando o projeto — Executando o comando de criação

mvn io.quarkus:quarkus-maven-plugin:1.11.1.Final:create \

-DprojectGroupId=br.com.mp \  
-DprojectArtifactId=food \  
-DclassName="br.com.mp.FoodResource" \  
-Dpath="/food"

// Log omitido

[INFO] Your application will be accessible on http://localhost:8080

[INFO] ------------------------------------------------------------------------

[INFO] BUILD SUCCESS

[INFO] ------------------------------------------------------------------------

[INFO] Total time: 42.305 s

[INFO] Finished at: 2019-12-12T09:36:11-02:00

[INFO] ------------------------------------------------------------------------

Log completo você encontra aqui: https://pastebin.com/UfczCUDL

Observação: A criação do projeto pode levar um tempo, já que o Maven, irá realizar o download de todas as dependências

Abra a aplicação em sua IDE preferida

Para esse exemplo, estou utilizando o InteliJ, porém, gosto bastante do Eclipse e Visual code, sinta-se a vontade para escolher sua IDE favorita.

Na imagem abaixo, podemos ver a estrutura do projeto (Maven), ressaltando a criação dos arquivos dentro da pasta Docker, Dockerfile.jvm e Dockerfile.native, que pretendo falar em um outro artigo. Logo abaixo, veremos o arquivo FoodResource, essa classe é a responsável por “expor” a API.

Executando o projeto inicial

No terminal, execute o comando abaixo:

mvn compile quarkus:dev

Resultado da execução:

Possivelmente, na primeira execução o compilador irá verificar se existe alguma dependência para baixar, como no exemplo abaixo.

[INFO] Scanning for projects...

[INFO]

[INFO] ---------------------------< br.com.mp:food >---------------------------

[INFO] Building food 1.0-SNAPSHOT

[INFO] --------------------------------[ jar ]---------------------------------

[INFO]

[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ food ---

[INFO] Using 'UTF-8' encoding to copy filtered resources.

[INFO] Copying 2 resources

// LOG OMITIDO

[INFO] ---------------------------< br.com.mp:food >---------------------------

[INFO] Building food 1.0-SNAPSHOT

[INFO] --------------------------------[ jar ]---------------------------------

[INFO]

[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ food ---

2019-12-12 15:12:19,730 INFO io.quarkus Quarkus 1.0.1.Final started in 0.735s. Listening on: http://0.0.0.0:8080

2019-12-12 15:12:19,740 INFO io.quarkus Profile dev activated. Live Coding activated.

2019-12-12 15:12:19,741 INFO io.quarkus Installed features: [cdi, resteasy]

Log completo da execução da aplicação: https://pastebin.com/pnLdVYsc

No final Log, aparece a URL para acessar com o navegador.

io.quarkus Quarkus 1.0.1.Final started in 0.735s. Listening on: http://0.0.0.0:8080

Você pode acessar a API através dos endereços: http://localhost:8080, http://0.0.0.0:8080 ou http://127.0.0.1:8080.

Para acessar a página, basta clicar no endereço exposto no terminal ou simplesmente copiar e colar no seu navegador, como mostrado no exemplo abaixo:

Testando a API /food, através do navegador

A URI da nossa API está definida inicialmente na classe FoodResource.java, com o caminho : /food

Abra o navegador e digite o endereço: http://localhost:8080/food, conforme a imagem a seguir:

Executando uma instância do Postgresql no Docker

Para armazenar as informações, vamos subir uma instância do Postgresql, utilizando o Docker, para isso, é necessário ter o Docker instalado e executar o comando listado abaixo:

Criando uma instância do Postgressql através do Docker

docker run --name postgres-food -e "POSTGRES_PASSWORD=postgres" -p 5433:5432 -v ~/developer/PostgreSQL:/var/lib/postgresql/data -d postgres

Observação: Precisei mudar a porta padrão de 5432 para 5433, já que tinha uma outra instância rodando aqui.

Vamos testar a conexão com o Banco de dados, no meu caso, eu estou utilizando o DBeaver 6.1.0, porém, existem diversas outras aplicações para conectar com o Banco de Dados PostgreSQL, abaixo, segue o teste da conexão do banco de dados:

No cliente SQL, vamos abrir o schema do Banco de dados e percebemos que o mesmo está vazio, não existe nenhuma tabela criada.

Voltando para a nossa aplicação

Retorne para sua IDE e adicione as seguintes dependências para o PanacheEntity e a dependência do Postgresql, as informações devem ser adicionadas no arquivo pom.xml (Na raiz do projeto).

io.quarkus

quarkus-hibernate-orm-panache

io.quarkus

quarkus-jdbc-postgresql

io.quarkus

quarkus-resteasy-jsonb

O Panache Entity visa facilitar a implementação da camada de persistência da aplicação. Além disso, o framework trás diversos métodos como Count, ListAll(), findById, persist, delete já implementados, conforme exibido código abaixo

Exemplo do PanacheEntity (Retirado do site: https://quarkus.io/guides/hibernate-orm-panache)

// creating a person

Person person = new Person();

person.name = "Stef";

person.birth = LocalDate.of(1910, Month.FEBRUARY, 1);

person.status = Status.Alive;

// persist it

person.persist();

// note that once persisted, you don't need to explicitly save your entity: all

// modifications are automatically persisted on transaction commit.

// check if it's persistent

if(person.isPersistent()){

// delete it

person.delete();

}

// getting a list of all Person entities

List allPersons = Person.listAll();

// finding a specific person by ID

person = Person.findById(personId);

// finding all living persons

List livingPersons = Person.list("status", Status.Alive);

// counting all persons

long countAll = Person.count();

// counting all living persons

long countAlive = Person.count("status", Status.Alive);

// delete all living persons

Person.delete("status", Status.Alive);

// delete all persons

Person.deleteAll();

Observação: O PanacheEntity é muito interessante, porém, vou explicar melhor em um artigo futuro.

Voltando para a implementação da classe de modelo (Entity)

Na IDE, crie a classe (Entidade): Food.java, dentro da pasta br.com.food.entity.

Classe: Food.java

package br.com.food.entity;

import io.quarkus.hibernate.orm.panache.PanacheEntityBase;

import javax.persistence.*;

import java.util.Objects;

@Entity

public class Food extends PanacheEntityBase {

@Id  
@GeneratedValue(strategy = GenerationType.IDENTITY)  
private Long id;  

@Column  
private String name;  

@Column  
private Double calories;

// Omitido

}

Configurando a conexão de Banco de dados no projeto

Procure o arquivo application.properties, dentro da pasta resources e adicione as seguintes configurações:

configure your datasource

quarkus.datasource.url = jdbc:postgresql://localhost:5433/food

quarkus.datasource.driver = org.postgresql.Driver

quarkus.datasource.username = postgres

quarkus.datasource.password = postgres

drop and create the database at startup (use `update` to only update the schema)

quarkus.hibernate-orm.database.generation = drop-and-create

Ao executar nossa aplicação, nos deparamos com o seguinte problema: Caused by: org.postgresql.util.PSQLException: FATAL: database “food” does not exist

Caused by: org.postgresql.util.PSQLException: FATAL: database "food" does not exist

at org.postgresql.core.v3.QueryExecutorImpl.receiveErrorResponse(QueryExecutorImpl.java:2468)

at org.postgresql.core.v3.QueryExecutorImpl.readStartupMessages(QueryExecutorImpl.java:2587)

at org.postgresql.core.v3.QueryExecutorImpl.(QueryExecutorImpl.java:134)

at org.postgresql.core.v3.ConnectionFactoryImpl.openConnectionImpl(ConnectionFactoryImpl.java:250)

at org.postgresql.core.ConnectionFactory.openConnection(ConnectionFactory.java:49)

at org.postgresql.jdbc.PgConnection.(PgConnection.java:195)

at org.postgresql.Driver.makeConnection(Driver.java:458)

at org.postgresql.Driver.connect(Driver.java:260)

Solução: Criar um Database no Postgresql, através do ClienteSQL

Executando a aplicação com o Banco de Dados configurado

Retornando para a nossa IDE, vamos executar o comando que irá iniciar nossa aplicação:

$ mvn compile quarkus:dev

[INFO] Scanning for projects...

[INFO]

[INFO] --------------------------< br.com.food:food >--------------------------

[INFO] Building food 1.0-SNAPSHOT

[INFO] --------------------------------[ jar ]---------------------------------

[INFO]

[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ food ---

[INFO] Using 'UTF-8' encoding to copy filtered resources.

[INFO] Copying 2 resources

[INFO]

[INFO] --- maven-compiler-plugin:3.8.1:compile (default-compile) @ food ---

[INFO] Changes detected - recompiling the module!

[INFO] Compiling 2 source files to /home/marcus/Estudo/Quarkus/food/target/classes

[INFO]

[INFO] --- quarkus-maven-plugin:1.0.1.Final:dev (default-cli) @ food ---

Listening for transport dt_socket at address: 5005

2019-12-12 16:44:24,885 WARN org.hib.eng.jdb.spi.SqlExceptionHelper SQL Warning Code: 0, SQLState: 00000

2019-12-12 16:44:24,891 WARN org.hib.eng.jdb.spi.SqlExceptionHelper table "food" does not exist, skipping

2019-12-12 16:44:25,135 INFO io.quarkus Quarkus 1.0.1.Final started in 1.715s. Listening on: http://0.0.0.0:8080

2019-12-12 16:44:25,136 INFO io.quarkus Profile dev activated. Live Coding activated.

2019-12-12 16:44:25,136 INFO io.quarkus Installed features: [agroal, cdi, hibernate-orm, hibernate-orm-panache, jdbc-postgresql, narayana-jta, resteasy]

Obversação 1: Assim que finalizar a execução, percebemos que a tabela Food foi criada no banco de dados.

Obvervação 2: Caso não queira o comportamento de criação automatica do banco de dados, basta comentar ou remover a linha: “quarkus.hibernate-orm.database.generation = drop-and-create”, de dentro do arquivo do application.properties.

Verificando se a tabela foi criada no Banco de Dados.

Espero que esteja gostando desse artigo.

Implementando uma simples classe de negócio

Crie uma classe chamada de FoodController.java, dentro da pasta br.com.food.controller. Essa classe será responsável por conter uma regra de negócio simples.

@ApplicationScoped

public class FoodController {

public Food update(Long id, Food food) {  
    Food foodEntity = Food.findById(id);

    if (foodEntity == null) {  
        throw new WebApplicationException("Food with id of " + id + " does not exist.", Response.Status.NOT_FOUND);  
    }

    foodEntity.setName(food.getName());  
    foodEntity.setCalories(food.getCalories());

    return foodEntity;  
}

/**  
 * This method is main purpose to show simple "Business" example  
 * @param food  
 * @return  
 */  
public boolean isFoodNameIsNotEmpty(Food food) {  
    return food.getName().isEmpty();

}

}

Implementação do FoodResouce.java

A classe FoodResource, é responsável por expor a API com os métodos para cadastro, edição, remoção e lista de todos os alimentos cadastrados.

FoodResource.java

package br.com.food.resource;

// OMITIDO

@path("/food")

@Produces(MediaType.APPLICATION_JSON)

@Consumes(MediaType.APPLICATION_JSON)

public class FoodResource {

@Inject  
private FoodController foodController;

@GET  
public List<Food> findAll() {  
    return Food.listAll();  
}

@POST  
@Transactional  
public Response create(Food food) {  
    Food.persist(food);  
    return Response.ok(food).status(201).build();  
}

@PUT  
@Path("{id}")  
@Transactional  
public Response update(@PathParam("id") Long id, Food food) {

    if (foodController.isFoodNameIsNotEmpty(food)) {  
        return Response.ok("Food was not found").type(MediaType.APPLICATION_JSON_TYPE).build();  
    }

    Food foodEntity = foodController.update(id, food);

    return Response.ok(foodEntity).build();  
}

@DELETE  
@Path("{id}")  
@Transactional  
public Response delete(@PathParam("id") Long id) {  
    Food foodEntity = Food.findById(id);

    if (foodEntity == null) {  
        throw new WebApplicationException("Food with id " + id + " does not exist.", Response.Status.NOT_FOUND);  
    }

    foodEntity.delete();  
    return Response.status(204).build();  
}

}

Observação: Reparem que é possível efetuar uma operação de persistência tanto na camada de Resource(API), quanto na classe de negócio ou até mesmo em uma classe Data Access Object — DAO.

Testando a API através do Postman

Abra o Postman, selecione o método POST e digite a URL: http://localhost:8080/food. Adicionalmente, adicione um Body com os dados conforme a imagem abaixo:

Cadastrando outro alimento no Postman

Listando todas os alimentos no Postman

No Postman, crie uma outra requisição do tipo GET e digite a url: http://localhost:8080/food, o resultado será a lista de todos os alimentos cadastrados no banco de dados, conforme a imagem abaixo:

Postman — Atualizando um objeto

Para atualizar a descrição e/ou a caloria de um alimento, basta criar uma nova requisição do tipo PUT, adicionar no final da URL o código (ID) do alimento que modificado. Não esqueça de preencher o body, que contém o JSON do objeto alterado.

Verificando os registros no Banco de Dados

Removendo um alimento através do Postman

Listando todos os alimentos através do Postman

No último teste, será listado todos os alimentos que estão cadastrados no banco de dados.

Conclusão

Esse é o meu primeiro artigo e espero que vocês tenham gostado, sinta-se à vontade para sugerir, criticar ou elogiar. Um grande abraço e até a próxima.

Código-Fonte

O código-fonte está disponível no endereço: https://github.com/marcuspaulo/quarkus-food

Forem: Marcus Paulo

Tutorial: Publish a Quarkus application in Kubernetes, Minikube and Dockerhub

Notes

Introduction

Prerequisites

Create a simple Quarkus application by command line

Access the project folder

In the next step, let’s go to test the project

Result in terminal (console)

Creating a local Container Registry in Minikube

Create Docker image with Quarkus by command line

Kubernetes and Minikube manifest create

List of all docker images

In the next step, we need to apply Minikube manifest to publish in Minikube Kubernetes

List of all pods

Access the application at the local machine

Access application in browser

Publish the image to Dockerhub

In my case, it happened this error

Publish in the Dockerhub

Source code

References

Tutorial: Disponibilizando uma aplicação Quarkus no Kubernetes utilizando o Minikube e/ou DockerHub

Introdução

Leituras adicionais

Publicações:

Pré-Requisitos para esse tutorial

Criar o projeto no Quarkus

Entre na pasta do projeto

Testando o projeto

Resultado

Adicionando a dependência do Minikube

Definindo o Minikube como Container Registry local

Gerando a imagem do Docker

Geração dos manifestos

Consultando a imagem gerada

Aplicando os manifestos do Minikube

Consultando os PODS

Port-Forward para acessar na máquina local

Acessando a aplicação que foi disponibilizada pelo Minikube

Enviando a imagem para o Dockerhub

Enviando a imagem para o Dockerhub

Erro ao enviar a imagem para o Dockerhub

Enviando para o Dockerhub

Código-fonte

Referências

Simplificando o Hibernate utilizando Panache - criando uma aplicação simples utilizando Quarkus Java + REST + CDI + Panache

Tutorial: Quarkus — Simplificando o Hibernate utilizando Panache — criando uma aplicação simples utilizando Quarkus Java + REST + CDI + Panache

Introdução

Métodos da classe PanacheEntityBase

Parte prática — Hands-on (Tutorial passo a passo)

Requisitos mínimos:

Instruções Adicionais:

Escopo da aplicação

Configurando o Panache no Projeto

configure your datasource

drop and create the database at startup (use update to only update the schema)

Adicione as dependências do Panache no pom.xml.

Executando uma instância do Postgresql no Docker

Criando uma instância do Postgressql através do Docker

Entidade Car (o modelo da aplicação)

Testando a aplicação

Listando todos os Carros (Versão 1)

Resultado no Postman

Postman — Listar todos os veículos na versão 2 da API

Criando um veículo (Versão 1)

Evoluindo a criação de um veículo

Postman — Resultado da inclusão de um veículo

Listando os carros por ano

Postman — Resultado da busca de veículos por ano

Outros métodos:

Listar todos os carros que estão disponíveis para venda

Listar todos os veículos ordenados por Nome e Marca.

Listar todos os veículos passando o ano como Parâmetro

Listar veículos com paginação

Atualizar veículo

Conclusão

Código-Fonte

Tutorial: Criando um CRUD utilizando Quarkus Java + REST + CDI + Panache, Hibernate com Postgres (Docker) + Postman

Tutorial: Criando um CRUD utilizando Quarkus Java + REST + CDI + Panache, Hibernate com Postgres (Docker) + Postman

drop and create the database at startup (use `update` to only update the schema)

drop and create the database at startup (use `update` to only update the schema)