Conhecendo o Payara Micro.

20150906224045
Logo Payara

Neste post vamos conhecer um pouco sobre o Payara Micro para desenvolver aplicações modernas com Java EE / Jakarta EE .

Introdução ao Payara Micro

Payara Micro é uma plataforma de middleware de código aberto criada a partir do lançamento do Payara Embedded Web para implementações de microsserviços Java EE (Jakarta EE) em container.

Com menos de 70 MB de tamanho, a Payara Micro não requer instalação ou configuração e não precisa de regravação de código – para que você possa criar e implantar um aplicativo totalmente funcional em poucos minutos.

Compatível com o Eclipse MicroProfile, o Payara Micro é uma versão pronta para microservices do Payara Server. Você pode executar arquivos war a partir da linha de comandos sem qualquer instalação do servidor de aplicativos. O cluster automático e elástico torna a Payara Micro ideal para executar aplicativos Java EE em uma infraestrutura virtualizada moderna.

 Além das api do MicroProfile 1.2 :

  • JAX-RS 2.0
  • CDI 2 (updated 1.2 → 2)
  • JSON-P 1.0
  • Annotation 1.2
  • Microprofile Config 1.1
  • Microprofile Fault Tolerance 1.0
  • Microprofile Health 1.0
  • Microprofile Metrics 1.0
  • Microprofile JWT Propagation 1.0

Payara micro tambem suporta as api do Java EE como :

  • Servlets, JSTL, EL and JSPs
  • WebSockets
  • JSF
  • JAX-RS
  • EJB lite
  • JTA
  • JPA
  • Bean Validation
  • CDI
  • Interceptors
  • JBatch
  • Concurrency
  • JCache
  • JCA
  • e muito mais.

Bem feita essa rápida introdução sobre o Payara Micro, vamos para a parte legal, a prática .

Requisitos

Para podemos utilizar a versao mais recente do Payara Micro, precisamos atualizar o nosso JDK para a versão 8u162 ou maior, devido a uma restrição na versão mais recente do Grizzly . 

Feita essa atulização,podemos fazer o download o Payara micro aqui ou podemos fazer o uso de uma imagem docker .

Criando uma instancia 

Para criar uma instancia do Payara Micro basta passar o seguinte comando :


java -jar payara-micro-5.181.jar

com esse único comando você tem um micro servidor rodando conforme a imagem :

START

Deploy das Aplicações

Para realizamos o deploy das nossas aplicações Java EE/Jakarta EE tambem é muito simples conforme o comando abaixo :

java -jar payara-micro-5.181.jar --deploy caminhoDoMeuWAR

aqui o comando “–deploy” é opcional, desde a versão 4.1.2.181 e 5.181.

vejamos um exemplo de deploy de um app em Servlet :

java -jar payara-micro-5.181.jar demoServlet.war

run

após executar o comando, o micro servidor ira fazer o deploy do nosso demoServlet.war e no final ira exibir a url para acessar o recurso, que no caso seria , agora abra o url no browser e adicione ao final da url o caminho para chamar o servlet: “http://192.168.1.6/demoServlet/HelloPayaraMicro :

run2

Além disso podemos fazer deploy de multiplos war dentro do Payara Micro com o seguinte comando :

java -jar payara-micro-5.181.jar demoServlet.war demoServlet2.war

run3

agora temos duas Servlet rodando no Payara Micro, porem existe uma outra forma de fazer isso de maneira mais rapida, que seria criar um novo diretorio e dentro dele adicionar todos os war e em seguinda utilizar o seguinte comando  :

java -jar payara-micro-5.181.jar --deploymentDir /localDasWAR

 

Gerando Uber Jar

È possivel tambem com o Payara Micro gerar um jar executavel pela linha de comando, desta forma podemos empacotar o aplicativo (ou aplicativos), configuração e dependências em um único jar com o seguinte comando :

 

java -jar payara-micro-5.181.jar demoServlet.war --outputUberJar demoServlet.jar 

e em seguida executar o comando :

 

java -jar demoServlet.jar 

 

Clustering no Payara Micro

O Payara Micro Cluster é baseado no Hazelcast, similarmente ao clustering da Hazelcast no Payara Server. Cada nó em um cluster da Payara Micro é efetivamente um nó Hazelcast.

Isso facilita a escalabilidade da infraestrutura para nossos aplicativos dinamicamente, sem nenhuma configuração complexa ou tempo de inatividade.

A integração da Hazelcast na Payara Micro permite que as instâncias se agrupem automáticamente e dinamicamente. Quando duas instâncias são apontadas no mesmo endereço e porta multicast, elas serão automaticamente agrupadas.

Vejamos um exemplo de executação de 2 instancias do Payara Micro em porta diferentes :

java -jar payara-micro-5.181.jar demoServlet.war --autoBindHttp

a opçao “–autoBindHttp” é usado para obter diferente configuração de porta, ou seja, quando executarmo duas vezes o comando acima teremos 2 instancias do Payara Micro com o mesmo endereço IP porem com porta diferentes, algo como 8080,8081… .

após  a execução em um dos terminal vai esta conforme a imagem abaixo :

das

pronto temos nossas aplicações em modo cluster, em nosso caso, ele se juntou ao Domain Data Grid que é o novo modo de descoberta para o Payara Micro e Payara Server, você pode aprender um pouco mais sobre o mesmo nesse artigo .

Payara Micro Maven Plugin

Para finalizar, iremos ver como podemos executar e gerar um Uber Jar com o plugin do Maven .

Crie um novo projeto com o seguinte conteúdo no pom.xml:

para mais detalhes sobre o que cada tag representa, acessa o link da documentação.

Para executar faça o seguinte :


mvn clean package payara-micro:bundle && mvn payara-micro:start

feito isso sua aplicação estará em execução escutando a porta 8080 que é a padrão.

Bem isso é tudo, espero que os leitores tenham gostado de conhecer um pouco sobre Payara Micro como alternativa light a servidores de aplicação full como Payara Server/GlassFish ,etc .

código de exemplo no meu github .

voce pode aprender mais nos seguintes links :

REFERÊNCIAS

Anúncios

Eclipse Che sua IDE na nuvem.

wl-eclipse-che

Neste post veremos como podemos utilizar a IDE Cloud Eclipse Che para para desenvolver nossas aplicações Java .

Introdução ao Eclipse Che

Eclipse Che é um servidor de WorkSpace baseado em Java de código aberto uma IDE em nuvem que fornece uma plataforma de desenvolvimento remoto para fins de multiusuários . O Servidor de WorkSpace vem com um serviço de RestFul e oferece alta flexibilidade, além de conter um SDK que pode ser usado para criar plugins para linguagens, ferramente ou frameworks.

A principal diferença entre o Eclipse Che e o Eclise IDE padrão é a capacidade de criar contêiner Docker para executar os aplicativos.

O eclipse Che suporta as seguintes Linguagens e Frameworks :

  • C++ , Java, JavaScript, PHP, Python, Ruby, SQL
  • .Net 2.0, AngularJS, Docker, OpenShift, Yeoman
  • Ant, Bower, Grunt, Gulp Maven, Npm
  • Git, Orion, SSH, SubVersion

Após a carga inicial, a IDE fornece uma interface de usuário dinâmica, incluindo componentes conhecidos como assistentes, editores, barras de ferramentas e muito mais. O usuário tem a oportunidade de criar espaços de trabalho, projetos, ambientes, máquinas e muitos outros módulos que são necessários para criar um projeto a partir do zero.

A comunicação entre a interface do usuário e o servidor é feita usando as APIs RESTful que interagem com o chamado Master de WorkSpace .

Um espaço de trabalho pode incluir zero ou mais projetos e deve, pelo menos, incluir um ambiente, que ele próprio contém pelo menos uma máquina.

Uma máquina é um tempo de execução que possui o software necessário. Se o usuário adicionar, por exemplo, um projeto que usa o Apache Maven, o Workspace Master instala o Maven em qualquer máquina no espaço de trabalho para garantir que o projeto possa ser executado em cada máquina.

Che vem com algumas pilhas de tecnologia predefinidas para configurar rapidamente uma nova máquina. Para garantir alta flexibilidade e extensibilidade, o usuário também pode definir pilhas de tecnologia personalizadas que podem ser usadas para configurar novas máquinas. Por padrão o Eclipse Che é executado em um servidor Apache Tomcat utilizando a porta 8080.

O leitor pode ler mais sobre o assunto nos seguintes links :

Bem feita essa rápida introdução sobre o Eclipse Che, vamos partir para a parte legal, a prática .

Requisitos

  • Docker 17+  instalado em sua maquina -> Download .

Feito a instalação do Docker , podemos seguir com a instalação do Eclipse Che .

Instalando o Eclipse Che

Para instalar execute o seguinte comando :


docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data
eclipse/che:6.1.1 start

A  apos esse comando, ele ira baixar as imagens necessárias para sua inicialização e a saída sera semelhante a essa :

start

Antes de fazemos qualquer coisa, iremos modificar algumas coisa em sua configuração, como habilitar o uso externo do Maven local, utilizar o Eclipse Che em modo OFFLINE e alterar o modo de como o Eclipse Che faz o Pull das imagens .

Primeiro de tudo, pare a execução do container e remova o mesmo com o seguinte comando :

docker stop che && docker rm che

apos isso vamos alterar o seguinte arquivo  “che.env” que fica localizado da pasta Data na hora de monta o volume, no meu caso fica em “/home/daniel/eclipseChe/data“, abra o arquivo dando acesso para alteração ao mesmo e procure e descomente os seguintes trechos :

  • CHE_DOCKER_ALWAYS__PULL__IMAGE=false : Se TRUE, o Che sempre ira fazer PULL de uma imagem do registro, mesmo que seja armazenada em Cache. Se FALSE, o Docker so faz pull se a imagem não existir localmente.
  • CHE_WORKSPACE_VOLUME= : Uma lista separada por “;” para montagem de volumes. Che ira montar o volume destas pasta host em cada workspace. Esse é uma maneira de permitir que você forneça acesso compartilhado em vários workspace . No meu caso ficaria assim :

CHE_WORKSPACE_VOLUME=/opt/apache-maven-3.5.2/repo:/home/user/.m2/repository;

/data/db:/data/db;

/home/daniel/oracle/postgre/data/:/var/lib/postgresql/data;

feita essas mudanças salve o arquivo, vamos partir para o modo OFFLINE .

A instalação offline baixa a CLI, as principais imagens do sistema e todas as imagens de pilha enquanto você está dentro de uma DMZ de rede com acesso DockerHub. Você pode então mover esses arquivos para um ambiente seguro e começar o Che.

1-  Salvando as imagens :

Enquanto estiver conectado a internet o Che ira fazer o download das imagens docker com o seguinte comando :


docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data
eclipse/che:6.1.1 offline

a saída será semelhante a essa :

offline

no meu caso ele só fez o download do “docker_compose:1.10.1.tar”, pois já tenho as outras imagem baixadas anteriormente.

A CLI irá baixar imagens e salvá-las em /backup/*.tar com cada imagem salva como seu próprio arquivo. Você pode salvar esses arquivos em uma localização diferente por volume, montando uma pasta local para: / data / backup. A tag de versão da imagem CLI Docker será usada para determinar quais versões de imagens dependentes para download. Há cerca de 1GB de dados que serão salvos.

Você também pode fazer o download das Stacks separadamente com o seguinte comando :


docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data
eclipse/che:6.1.1 offline --list

ao executar ira mostrar uma lista de imagens conforme a imagem :
stacks
para fazer o download de uma stack especifica executamos o seguinte comando :
docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data
eclipse/che:6.1.1 offline --image:nomeDaImagem

feito isso podemos iniciar nosso Eclipse Che em modo OFFLINE e iniciar nosso Hello-World .

Para iniciar o Eclipse Che execute o seguinte comando :


docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data eclipse/che:6.1.1 start --offline

a saída sera semelhante a essa com todos os tar’s carregados :

offiline2

agora basta abri o seu navegador passando o endereço informado na tela, que no meu caso é http://192.168.1.100:8090 e a seguinte tela ira abrir :

workspace

No meu caso meu “Dashboard” contem um workspace criado com 2 projetos nele. Vamos criar um do zero agora .

Criando o WorkSpace

Primeiramente clique em “Create Workspace “, isso ira abri a seguinte tela :

newWorkspacenewWorkspace2

Nesta tela é aonde criamos nosso workspace com algumas stack prontas uso .

Uma Stack é um modelo de configuração de workspace e algumas meta-informações como escopo, tags, componentes, descrição, nome e ID. As Stacks são usadas pelo Dashboard para facilitar a criação de workspace e bem como projetos de exemplo de filtro compatíveis com uma pilha escolhida.

As pilhas são exibidas no Painel do Usuário na página Criar uma área de trabalho. Você pode filtrá-los por tipo (single vs multi machine), scope (os exibidos por padrão vs outros), bem como procurar uma pilha por palavra-chave.

Para o primeiro exemplo iremos criar um projeto simples com uma Servlet, então fazemos o seguinte :

1 – De um nome para o WorkSpace.

2 – Escolha a Stack “Java” abaixo da Stack “Blank”

3 – Clique em “CREATE”

4 – ira apresentar uma popup com duas opções “Edit” ou “Open in IDE”, escolha a segunda opção .

Apos isso ira abri o editor conforme a imagem :

tela

Com a tela aberta vá no menu “Workspace” e clique em “Create Project” ou aperte “Alt + X” ira abir a seguinte tela :

newProject

escolha “Maven” e preencha o formulário de next e configure da seguinte forma :

newProject2

logo apos ira ter um projeto chamado Demo na workspace :

project

feito isso, abra o pom.xml e configure da seguinte forma :

 

depois clique com botão direito no seu projeto e vá no menu “Maven” ->”ReImport”, feito isso crie um “pacote” na pasta “java”  e em seguida cria uma classe Java com o seguinte conteúdo :


package br.org.soujava.rio.minhaServlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/minhaServlet")
public class MinhaServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {

  PrintWriter out = response.getWriter();
  out.println("<h1>Minha Primeira Servlet com Eclipse CHE.</h1>");
  }
}

 

feito isso, vá na aba “Manage Commands” conforme a imagem :

manage

em seguida altere o “build ” com o seguinte comando  na parte “Command Line”, clique em “Save” e depois em “Run” :


mvn -f ${current.project.path} clean install
cp ${current.project.path}/target/*.war /home/user/tomcat8/webapps/

 

Apos isso, seu o projeto vai esta na pasta do Tomcat, agora para executar vamos criar um outro comando, para isso clique me “RUN” escolha a opção “Maven” e adicione o seguinte comando na “Command Line:


$TOMCAT_HOME/bin/./startup.sh

 

e em “Preview URL adicione o seguinte comando:


${server.tomcat8}/Demo-1.0-SNAPSHOT/minhaServlet

 

salve e execute e acesse o seguinte endereço : http://seuIp:32769/Demo-1.0-SNAPSHOT/minhaServlet :

servlet

parabéns conseguimos executar nossa primeira Servlet com Eclipse Che .

Os comandos são instruções de script que são injetadas na máquina do espaço de trabalho para execução. Os comandos são salvos no armazenamento de configuração do seu espaço de trabalho e fazem parte de qualquer exportação de espaço de trabalho.

para aprender mais sobre os comandos acesse o seguinte link.

A próxima demo faremos uso de múltipla maquinas onde iremos conectar nossas aplicações ao um Banco de Dados ou qualquer outra coisa. No nosso caso iremos usar um banco de dados.

Se o leitor percebeu la no começo quando estávamos criando uma workspace tinha varias stacks prontas para uso inclusive uma com Java + MySQL, porem o leitor pode não querer usar o MySQL, mas sim um PostGres ou até mesmo um NoSQL como MONGO DB.

Como podemos perceber não temos Stack para a mesma, então a gente ira criar uma stack personalizada se baseando na stack do MySQL.

Para isso vamos no menu “Stacks” conforme a imagem :

stacks2

nessa tela procure por “Java-MySQL” e clique em “Duplicate Stack” , logo em seguida clique na Stack duplicada e sera apresentada a seguinte tela :

newStarkc

agora vamos configurá-la para ele ser um Stack com banco NoSQL- MongoDB

1 – Altere o nome da stack para Java-Mongo ou qualquer outro nome.

2 – em “Machines” altere o “db”  :

2-1 – em “Source” adicionar : “mongo:latest” esse é o nome da imagem que o docker ira fazer o pull .

2-2 – em “Servers” alterar a porta para “27017” e mudar o reference também.

3 – vá em “Raw Configuration” e altere o trecho “content” para :


content": "services:\n db:\n image: 'mongo:latest'\n mem_limit: 1073741824\n dev-machine:\n image: eclipse/ubuntu_jdk8\n mem_limit: 2147483648\n depends_on:\n - db\n"

 

o arquivo final fica assim :

logo em seguida salve a nova Stack e vamos utilizá-la agora, para isso crie um novo workspace e selecione a nova stack criada.

La no começo eu ensinei a apontar a pasta local para se comunicar com a pasta do conteiner no trecho : CHE_WORKSPACE_VOLUME= , aonde eu aponta minha pasta “data/db” para a do conteiner.

Feito isso clique me Create e em “Open in IDE”, ele ira iniciar o Mongo e logo em seguida ira iniciar o a maquina de Dev :

mongo

agora iremos criar um projeto para utilizar essa nova stack, para isso va no menu “Workspace” e clique em “Import Project” > “Git” e adicione o seguinte endereço :  https://github.com/Adopt-a-JSR/MVC1.0.Ozark.git e clique em import, logo em seguida selecione “Maven” depois em “Next”, selecione “war” e depois clique em “Save” .

feito isso, abra o pom.xml para fazermos algumas modificações :

agora iremos modifica duas classes :

1 – DocumentCollectionProducer.java = alterar “localhost” para “db” que é o nome da maquina do mongodb

2- PersonController.java =  adicionar o import  org.mvcspec.ozark.engine.Viewable;”

essa mudança é necessária pois estamos usando uma versão nova da lib da Ozark.

feito isso, vamos criar um comando para fazer o build e executar a aplicação .

no “Command Line” adicione o seguinte trecho :


mvn clean package -f ${current.project.path}

&& cd ${current.project.path}/target

&& java -jar payara-micro.jar --deploy MVC1.0.Ozark.war

e em “Preview URL” adicionar o seguinte trecho :


${server.tomcat8}/${current.project.relpath}

e clique em “Run” e acesso  o endereço : http://192.168.1.100:32802/MVC1.0.Ozark/ :

payara

Bem isso é tudo, espero que os leitores tenham gostado de conhecer um pouco sobre Eclipse Che.

Continue seus estudos explorando mais essa IDE e criando novos Stacks personalizadas.

mais exemplos: https://www.eclipse.org/che/docs/tutorials/multi-machine/index.html

REFERÊNCIAS