Començando com a GraalVM utilizando Java, Javascript e NodeJs.

Hoje vamos iniciar os primeiros passos com a maquina virtual poliglota desenvolvida pela Oracle. Sim, estamos falando da famosa GraalVM.

Na matéria de hoje, focaremos na instalação da GraalVM, no momento da publicação dessa matéria, a versão é a 20.0.0 baseada no JDK 11. Além de executar códigos Java, Javascript e subir um servidor em NodeJs, tudo isso com a GraalVM.

A poucas semana falamos um pouco sobre essa maquina virtual e o lançamento da sua versão 20.0.0. De qualquer modo vamos recapitular um pouco sobre.

O que é a GraalVM?

A GraalVM é uma máquina virtual universal Open Source criada pela Oracle que executa aplicativos escritos em JavaScript, Python, Ruby, R, linguagens que já rodam na JVM, como Java, Scala, Groovy, Kotlin, Clojure e linguagens baseadas em LLVM, como C e C ++.

A GraalVM remove o isolamento entre linguagens de programação e permite a interoperabilidade em um tempo de execução compartilhado. As imagens podem ser executadas standalone ou nos contextos do OpenJDK, Node.js ou Oracle Database. Essa interoperabilidade permite desenvolver em java e acessar funcionalidades de outras linguagens.

Instalação da GraalVM.

Para realizar o download e instalar a GraalVM, vamos utilizar um gerenciador de pacotes. Como estou no Windows 10, vou utilizar o Chocolatey.

Para realizar o download e instalação do Chocolatey, acesse esse link.

Para fazer instalação da GraalVM com o Chocolatey basta executarmos no terminal o comando:


>choco install graalvm

Automaticamente o Chocolatey já cria as variáveis de ambiente Path e o java_home. Caso já tenha um JDK instalado, ele ira sobrepor o java_home, mas duplicar o path, desse forma preste atenção nisso.

Apenas para auxiliar, minhas variáveis de ambiente ficaram conforme tabela abaixo:

Variável de ambiente Valor
JAVA_HOME C:\Program Files\GraalVM\graalvm-ce-java11-20.0.0
Path C:\Program Files\GraalVM\graalvm-ce-java11-20.0.0\bin

Após verificar e ajustar suas variáveis de ambiente, reinicie seu terminal e execute o comando java –version.

A instalação será parecida nos demais sistemas operacionais, mas de uma googlada antes de começar. De qualquer modo, há a possibilidade de utilizar um container Docker e subir uma imagem da GraalVM.

Utilizando a GraalVM com Docker.

Para isso use o comando docker pull:

>docker pull oracle/graalvm-ce:20.0.0

E realize o Start do container com o docker run com bash:

>docker run -it oracle/graalvm-ce:20.0.0 bash

Apresentada essa forma, vamos partir para o código.

Executando Javascript com a GraalVM.

Para executar códigos javascript, basta escrever no terminal “js” seguido de um enter. Feito isso você já pode dar “printar” um Hello World, ou melhor, Hello Home devido a quarentena, direto na linha de comando conforme exemplo abaixo:

Executando Java com a GraalVM.

Como de costume utilizaremos o famoso “javac” para compilar as classes java e o comando “java” para executar. Crie um arquivo HelloHome.java conforme código abaixo:

public class HelloHome {
    public static void main(String[] args) {
      System.out.println("Hello Home! Estamos em quarentena!");
    }
  }

Compile e o execute no terminal:

Subindo um servidor com NodeJS.

Primeiramente, vamos criar um workspace e acessa-lo com o terminal. Apenas para auxílio, criei da seguinte forma abaixo:

Execute o comando “npm init” para a criação do package.json. Serão questionados alguns parâmetros, por hora, apenas pressione enter até finalizar os questionamentos.

>npm init

Instale com o npm os módulos colors e ansispan que serão registrados no package.json:

>npm install colors ansispan

Ao final, seu workspace terá os arquivos abaixo:

Com um editor de texto, crie um arquivo app.js com o script abaixo e salve no mesmo workspace, junto dos arquivos de configuração que acabamos de criar.

const http = require("http");
const span = require("ansispan");
require("colors");

http.createServer(function (request, response) {
    response.writeHead(200, {"Content-Type": "text/html"});
    response.end(span("Hello Graal.js! Estamos em quarentena".green));
}).listen(8000, function() { console.log("Graal.js server running at http://127.0.0.1:8000/".red); });

De volta ao terminal, execute o arquivo app.js com a GraalVM utilizando o comando node.

>node app.js

Agora com o navegador, acesse seu localhost:

Caso queira derrubar o servidor, na linha de comando pressione Ctrl + c.

Epilogo

Conforme prometido, nessa matéria abordamos a instalação da GraalVM e executamos códigos Java, Javascript além de subir um servidor em NodeJs, tudo isso com a GraalVM.

Não houve nenhum mistério para essas atividades básicas. Caso queira saber mais sobre a versão 20.0.0, falei um pouco nessa matéria.

Muito obrigado e até a próxima.

Compartilhe e curta:

Deploy de um app SpringBoot 2 nas nuvens do Azure

Como é da sapiência de todos, o mundo está em quarentena. Pra mim e acredito que para uma boa parte dos desenvolvedores a rotina não muda muito, de qualquer modo, o Blog DevJava quer contribuir com um conteúdo bacana, a fim de incentivar que você realmente fique em casa. Faça sua parte, ajude que essa grave doença não se espalhe. Dessa forma, como é do nosso conhecimento, fique em casa e aproveite esse período para aprender coisas novas.

Nós do Blog DevJava preparamos uma matéria em que realizaremos juntos o deploy de uma pequena aplicação SpringBoot 2 na nuvem do Microsoft Azure. 

Será bem rápido, simples e para focar apenas no deploy, utilizaremos o app HelloWorld que desenvolvemos nesse último post sobre SpringBoot aqui. Apenas para refrescar a memória, Essa aplicação que fizemos outrora, expõe um endpoint que nos retorna uma mensagem de HelloWorld. 

Caso não tenha desenvolvido ainda, está aí a oportunidade. Caso prefira pular para o deploy, pode realizar o git clone do projeto no meu github pessoal por esse link: https://github.com/rafaelvcunha/HelloWorldSpringBoot2

Mas antes de iniciarmos a prática, vamos colocar alguns pingos nos is. 

O que é o Microsoft Azure?

Como o próprio site da microsoft o apresenta, o Azure é uma plataforma de computação em nuvem completa, nessa plataforma podemos criar, implantar e gerenciar serviços e aplicativos na nuvem. 

O que preciso para acessar o Azure?

Caso você ainda não tenha uma conta no Azure, a Microsoft disponibiliza 12 meses de serviços gratuitos, basta se cadastrar no link a seguir: https://azure.microsoft.com/pt-br/free/

Mas se como eu, já encerrou o período de testes, é possível utilizar a plataforma pagando apenas pelo que usar. Ao final do deploy, auxiliarei na exclusão dos recursos para que não fique gerando custos para ti, ou mesmo que eles sejam irrelevantes.

Pré-requisitos

Pré-requisitos para iniciarmos esse tutorial:

  • Uma conta no Microsoft Azure como descrito anteriormente;
  • Realizar a instalação do Azure CLI (interface de linha de comando). Pode ser feito o download ou saber mais nesse link https://docs.microsoft.com/pt-br/cli/azure/?view=azure-cli-latest
  • JDK LTS 8 ou 11 instalado com suas variáveis de ambientes configuradas;
  • Possuir o Maven com suas variáveis de ambientes configuradas;
  • Git instalado.
  • Ter realizado o git clone do app HelloWorldSpringBoot2 e importado o projeto maven na sua IDE de estimação.

Bora para a prática, que nem só de teoria ou blá blá blá se vive um desenvolvedor… rsrssrs.

Preparando nossa aplicação para o Azure

Abra o arquivo pom.xml do projeto em sua IDE de estimação. Dentro da tag “<plugins>” que estão abaixo de “<build>”, inclua o seguinte plugin do maven para aplicativos web do azure. Com ele, será possível implantar um aplicativo Spring Boot em um contêiner linux no azure. Segue código:

<plugin>
  <groupId>com.microsoft.azure</groupId>
  <artifactId>azure-webapp-maven-plugin</artifactId>
  <version>1.9.0</version>
</plugin>

Seu arquivo pom.xml ficará da seguinte forma:

Após isso vamos abrir um terminal da sua escolha, aqui utilizo o ConEmu, mas pode ser utilizado os nativos do seu sistema operacional mesmo. Caso queira fazer download do ConEmu, acesse esse link ( https://conemu.github.io/en/Downloads.html ).

Com o terminal aberto, vá até o diretório que está seu app, no meu caso no (C:\desenvolvimento\workspaces\workspace-sts4\HelloWorldSpringBoot2) e utilize o comando abaixo que acionará o plugin do azure para que ele configure sua app.

mvn azure-webapp:config

Será apresentado a seguinte mensagem:

Escolha as opção 1 ou apenas aperte enter. A seguinte opção é sobre a versão do java, no meu caso é o Java 8, então também pressione enter.

Enfim, a última opção é apenas confirmar as propriedades do nosso webapp.

Voltando para o nosso arquivo pom.xml, é possível identificar algumas mudanças realizadas pelo plugin.

Adicione a tag “<appSettings>” apresentada a seguir dentro da tag “<configuration>” do plugin azure-webapp-maven-plugin para escutar a porta 80.


<appSettings>
          <property>
                <name>JAVA_OPTS</name>
                <value>-Dserver.port=80</value>
          </property>
</appSettings>

Seu pom.xml ficará da seguinte forma:

Deploy da aplicação no Microsoft Azure

Após a preparação da aplicação, bora realizar o deploy do app SpringBoot no Azure? Para isso, abra seu terminal e realize login no Microsoft Azure com o seguinte comando:

az login

Será aberto seu navegador padrão e solicitado login com sua conta do Microsoft Azure conforme imagem abaixo:

Ao efetuar o login com sucesso, é apresentado a seguinte mensagem em seu navegador. Já no terminal é apresentando informações do seu acesso no formato Json.

Após realizar o login, volte ao terminal e utilize o comando abaixo para recompilar o arquivo Jar utilizando o Maven.

mvn clean package

Após o Build ter sido concluído com sucesso, implante seu aplicativo SpringBoot 2 no Azure utilizando o comando maven abaixo:

mvn azure-webapp:deploy

O terminal apresentará a mensagem Build Success, e logo na linha acima podemos notar a frase, “Successfully deployed the artifact to *URL*” . Pode ser que leve alguns minutos para que sua aplicação faça deploy e seja apresentado no portal Azure (https://portal.azure.com/), mas adianto que por aqui foi imediato.

Depois que a aplicação Spring Boot tiver sido implantada, você conseguirá gerenciá-la por meio do portal Azure.

Seu aplicativo Web será listado nos Serviços de Aplicativos conforme imagem abaixo:

A URL para acessar sua aplicação Springboot será apresentada na Visão geral de seu aplicativo Web:

Verifique se a implantação foi bem-sucedida em seu navegador utilizando a URL presente na imagem anterior, acrescentando o path “/hello” ao final. Você verá a seguinte mensagem exibida: 

Bazinga!!! Temos uma aplicação rodando nas nuvens do Microsoft Azure. 

Agora vamos colocar os pés no chão e deletar todos os recursos. De preferencia, caso sua conta como “paga pelo uso” e não queira que sejam gerados custos, mesmo que irrelevantes. No meu caso, devido alguns testes, gerou um custo de apenas 9 centavos como pode ser observado na imagem abaixo:

Desse forma, bora limpar os recursos que não serão mais utilizados.

Limpar os recursos criados

No portal do Microsoft Azure acesse no menu lateral esquerdo ou na tela inicial o “Grupo de recursos”.

Será aberta a seguinte tela, caso necessário utilize o filtro por nome com o prefixo “HelloWorld”.

Selecione o grupo que criamos e pressione “Delete Resource Group”.

Digite o nome do grupo de recursos no campo de texto e pressione Excluir.

Após alguns segundos ou minutos a exclusão total será finalizada.

Como se dizia no jogo Mortal Kombat, Finish Him… rsrssrrs.

Pronto, Grupo de recursos excluindo para sempre.

Epilogo

Subi esse projeto já preparado para o Azure no GitHub no repositório projeto HelloWorldSpringBoot2 mesmo, mas na branch AzureHelloWorld. Acesse aqui.

Quer mais materiais para estudar nessa quarentena?

Caso queira se capacitar de forma gratuita, em alguns posts passados, preparei alguns sites e canais do Youtube que nos ajudam com isso. acesse os links:

*Canais do YouTube para o(a) desenvolvedor(a) Java estudar gratuitamente;

*Sites para o(a) desenvolvedor(a) Java estudar de graça.


Compartilhe e curta:

Apresentando o Java 14 e suas novidades

Na tarde de ontem, 17 de março de 2020 a Oracle anunciou a chegada do Java SE 14, junto de sua implementação Java Development Kit versão 14, vulgo JDK 14.

Nessa matéria vamos apresentar cada um dos 16 aprimoramento entregues nesta versão com um breve resumo teórico para entendimento.

Desde o Java 9 a Oracle vem atualizando o Java SE a cada 6 meses, e entregando uma versão LTS  (Long Term Support) a cada dois anos. Com a chegada do JDK 14, o JDK 13 ficará obsoleto em breve. Outras versões que possuem suporte são os JDK 8 e JDK 11, ambos são LTS.

JEPs entregues no JDK 14

No JDK 14 foram entregues um total de 16 JEPs, apenas para compreensão, JEP é a abreviação de JDK Enhancement Proposals, traduzindo Propostas de aprimoramento do JDK.

Apenas para colocar os pingos nos is, quando é apresentado uma JEP Preview, ela é um novo recurso totalmente especificado, implementado, mas não permanente, podendo ou não se tornar permanente em uma versão futura do Java. Para se tornar permanente ou ser abandonada, depende dos feedbacks da comunidade.

Segue lista com cada aprimoramento e uma breve explicação sobre cada um:

JEP 305: Pattern Matching for instanceof (Preview)

Este JEP aprimora o Pattern Matching para o operador instanceof. Melhora a produtividade do desenvolvedor, eliminando a necessidade de repetição de código, possibilitando um código mais conciso fortemente tipado.

Hoje temos que realizar comparação da seguinte forma:


@Override public boolean equals(Object o) { 
    return (o instanceof CaseInsensitiveString) && 
        ((CaseInsensitiveString) o).s.equalsIgnoreCase(s); 
}

Com esse aprimoramento, podemos utilizar da forma abaixo:


@Override public boolean equals(Object o) { 
    return (o instanceof CaseInsensitiveString cis) && 
        cis.s.equalsIgnoreCase(s); 
}

JEP 343: Packaging Tool (Incubator)

Possibilita que o desenvolvedor empacote os aplicativos java em imagens nativas para diferentes plataformas, como windows, linux e MacOS. Isso ajuda no tempo de start da aplicação e no consumo inicial de memória.

JEP 345: NUMA-Aware Memory Allocation for G1

Essa feature melhora o desempenho geral do Garbage Collector G1 em sistemas NUMA (Non-Uniform Memory Access).

JEP 349: JFR Event Streaming

Essa feature expõe os dados do JDK Flight Recorder (JFR) para monitoramento contínuo, o que simplifica o acesso aos dados JFR para várias ferramentas e aplicativos.

JEP 352: Non-Volatile Mapped Byte Buffers

Adiciona um modo de mapeamento de arquivo para o JDK ao usar memória não volátil. A natureza persistente da memória não volátil altera várias suposições de persistência e desempenho que podem ser aproveitadas com essa feature .

JEP 358: Helpful NullPointerExceptions

Melhora as mensagens apresentadas em uma exception NullPointerExceptions , descrevendo com precisão qual variável era nula e outras informações úteis. Isso melhorará a produtividade do desenvolvedor e a qualidade de muitas ferramentas de desenvolvimento e depuração.

JEP 359: Records (Preview)

Fornece uma sintaxe compacta para declarar classes que contêm dados superficialmente imutáveis. Superficialmente, esse recurso reduz bastante o códigos repetidos em classes desse tipo, mas, seu objetivo é melhorar a modelagem de dados como dados. Deve ser fácil, claro e conciso declarar agregados de dados nominais superficialmente imutáveis.

JEP 361: Switch Expressions (Standard)

Foi uma feature preview no JDK 12 e 13 e agora é uma feature completa. Permite que o switch seja usado como uma declaração ou expressão. Essa feature simplifica a codificação diária e preparou o caminho para a feature pattern matching ( JEP 305 ), apenas preview nesta versão.

JEP 362: Deprecate the Solaris and SPARC Ports

Este JEP descontínua as portas Solaris e SPARC com a intenção de removê-las em uma release futura.

JEP 363: Remove the Concurrent Mark Sweep (CMS) Garbage Collector

O Garbage Collector CMS foi descontinuado há dois anos e o G1, seu sucessor desde o JDK 6, tem sido o GC padrão. Nesse meio tempo vimos a introdução de dois novos Garbage Collectors, ZGC e Shenandoah, enquanto houve muitas melhorias no G1.

JEP 364: ZGC on macOS

ZGC é um Garbage Collector escalável de baixa latência projetado para heaps de todos os tamanhos, não aumentando o tamanho do heap em tempos de pausa. Assim como hoje funciona em ambiente linux, o ZGC foi portado para MacOS.

JEP 365: ZGC on Windows

Assim como explicado anteriormente no JEP 364, o ZGC foi portado também para Windows.

JEP 366: Deprecate the ParallelScavenge + SerialOld GC Combination

Descontínua a combinação de algoritmos Parallel Scavenge e Serial Old do Garbage Collector, que raramente são usados, com a intenção de removê-lo em uma versão futura.

JEP 367: Remove the Pack200 Tools and API

Remove as ferramentas pack200 e unpack200, e a API Pack200 do pacote java.util.jar. Essas ferramentas e API foram descontinuadas no JDK 11.

JEP 368: Text Blocks (Second Preview)

Esta é a segunda preview referente a Text Blocks após ter sido incluído no JDK 13 ( JEP 355 ) e a comunidade ter realizado feedbacks sobre a feature. Com os Text Blocks é possível apresentar sequências de strings mais legíveis, evitando concatenações com o símbolo +, além de diminuir a utilização desenfreada de diversas aspas duplas.

Exemplo:

Agora utilizando Text Blocks:

JEP 370: Foreign-Memory Access API (Incubator)

Foi desenvolvida uma API para permitir que programas Java acessem com segurança e eficiência a memória externa fora do heap Java.

Download do JDK 14

Para realizar o download do JDK 14, basta acessar os links abaixo:

JDK 14: https://www.oracle.com/java/technologies/javase-jdk14-downloads.html

OpenJDK 14: https://jdk.java.net/14/

Epilogo

Após toda essa apresentação do Java 14, bora testar essas novas funcionalidades?

Caso queira se capacitar de forma gratuita, em alguns posts passados, preparei alguns sites e canais do Youtube que nos ajudam com isso. acesse os links:

*Canais do YouTube para o(a) desenvolvedor(a) Java estudar gratuitamente;

*Sites para o(a) desenvolvedor(a) Java estudar de graça.

Compartilhe e curta: