Distribuindo uma Aplicação MicroProfile no Oracle Container Native Platform

Por Rodrigo Cândido da Silva
Publicado em Novembro 2018

Revisado por Elder Moraes




MicroProfile é uma plataforma base de especificações e APIs que otimizam o ecossistema do Java Enterprise para uma arquitetura de microservices oferecendo portabilidade para diferentes implementações. Ele foi lançado em 2016 em uma iniciativa formada por alguns fornecedores Java EE (Red Hat, Payara, Tomitribe, IBM) e Java User Groups (SouJava e London Java Community) cujo objetivo principal era trazer inovações mais rápido ao ambiente Java Enterprise. Atualmente encontra-se na versão 2.1 suportada pela plataforma Java EE 8 e contempla as seguintes especificações:


Fonte: Eclipse MicroProfile blog



Thorntail (antigo Wildfly Swarm) é uma das possíveis implementações existentes de MicroProfile e já  oferece suporte à implementação das APIs MicroProfile 2.1. Ele é um framework baseado no servidor de aplicação Wildfly e possibilita a criação de pequenas aplicações standalone baseadas em microservices utilizando o modelo uber JAR. Para criar uma nova aplicação é bastante simples, basta utilizar o site Thorntail generator e informar o Maven group, artifact e as dependências necessárias a sua nova aplicação.     

 



Após clicar na geração, será fornecido um arquivo zip com a estrutura (fontes) do projeto gerado e pronto para realizar o desenvolvimento da aplicação. Você pode abrir este projeto em qualquer IDE com suporte à Maven e realizar o primeiro build. Para rodar a aplicação, basta digitar o seguinte comando Maven no console.

 mvn thorntail:run


Ao final desta execução, será demonstrada uma mensagem de sucesso (Thorntail is Ready) e ficará disponível para acesso local na porta 8080. Você pode testar esta aplicação utilizando uma das seguintes URLs:



Para movimentar sua aplicação MicroProfile para o ambiente de nuvem, é necessário distribuir sua aplicação em containers. Desta maneira então, será necessário adicionar a configuração Docker utilizando o seguinte arquivo Dockerfile.

      
FROM openjdk:8

EXPOSE 9990
EXPOSE 8080

ADD target/*.jar /app.jar

RUN sh -c 'touch /app.jar'

USER root

RUN touch /audit.log && chmod 777 /audit.log

CMD java -Djava.net.preferIPv4Stack=true -jar /app.jar



Você pode testar se a criação da imagem Docker este funcionando corretamente. Para isto será necessário primeiro realizar o build Maven da aplicação, gerando assim um uber JAR, e depois realizar o docker build respectivo com base no arquivo Dockerfile definido anteriormente.


mvn package
    
docker build -t microprofile .

 



Oracle Container Native Platform


Oracle Cloud é uma plataforma de computação em nuvem oferecido pela Oracle, provendo servidores, armazenamento, rede, aplicações e serviços em uma rede global de data centers gerenciados pela Oracle. Ela fornece soluções de Infra-estrutura como um serviço (IaaS), Plataforma como um serviço (PaaS), Software como um serviço (SaaS) e Data como um serviço (DaaS) que são utilizados para construir, distribuir e integrar aplicações em nuvem. Suporta inúmeros padrões abertos (SQL, HTML5, REST, etc), plataformas open-source (Kubernetes, Hadoop, Kafka, etc) e uma variedade de linguagens de programação, banco de dados, ferramentas, frameworks incluindo opções proprietárias Oracle ou de terceiros.

Dentre as soluções de PaaS oferecidas pela Oracle Cloud, encontra-se o Oracle Container Native Platform que é uma solução para desenvolvimento, build, distribuição e administração de containers integrada e facilitada que oferece uma experiência de entrega contínua para as aplicações (end-to-end). Ela é composta basicamente por três estruturas: Oracle Container Engine for Kubernetes (OKE), Oracle Cloud Infrastructure Registry (OCIR) e Oracle Container Pipelines (Wercker) integradas e rodando na infra-estrutura do Oracle Cloud.


Fonte: Oracle Container Native Platform website


  • Oracle OKE: cluster Kubernetes gerenciado pelo Oracle Cloud. É certificado pela Kubernetes foundation com suporte multi AZ, e uma interface de configuração e administração user-friendly;
  • Oracle OCIR: repositório de images Docker compatível com a versão 2 de registro Docker. Oferece tokens para autenticação, com suporte à alta escalabilidade e disponibilidade;
  • Oracle Wercker: ambiente CI/CD automatizado para containers totalmente integrado com a plataforma Oracle Cloud.


Esta plataforma promove o fácil desenvolvimento e distribuição de containers utilizando o conceito de pipelines com práticas de integração e entrega contínua. A seguinte imagem abaixo demonstra como funciona o ciclo de integração nesta plataforma.


Fonte: Oracle Cloud Infrastructure blog


Basicamente, os projetos são configurados inicialmente no Oracle Wercker por meio de pipelines de integração, que gerenciam as fases de build, testes, registro e publicação das imagens do repositório de registro de imagens OCIR. Neste repositório é possível manter um catálogo de imagens versionadas e rotuladas por projeto. Uma vez registrada a imagem, será possível realizar a distribuição da mesma para o ambiente de execução e orquestração de containers (OKE) gerenciado pelo Kubernetes. Você pode definir ambientes de orquestração de acordo com o perfil desejado de execução como desenvolvimento, staging e produção, cada qual com sua configuração (namespace) isolada e separada dos demais.

 



Criando um novo cluster Kubernetes no Oracle OKE


Para realizar a criação de um novo cluster Kubernetes basta acessar o dashboard do Oracle OKE e solicitar a opção (botão) para criar um novo cluster. Será aberto uma janela com opções e informações adicionais para criação, onde basta definir o nome do cluster, versão Kubernetes suportada, e a opção para criação rápida.



Além disto, é possível habilitar complementos como Kubernetes Dashboard e Tiller (Helm) para serem habilitados durante o processo de criação. Após a confirmação, será solicitada a criação do cluster que deverá estar disponível dentro de alguns minutos.



O cluster Kubernetes estará pronto assim que o status de criação demonstrar ativo, e as instâncias que compõem o cluster ficarem disponíveis.



Para acessar e administrar o ambiente do cluster Kubernetes remotamente, será necessário instalar e configurar o utilitário kubectl (Kubernetes command line) e o Oracle CLI (Oracle Cloud command line). Após a instalação e configuração destas ferramentas, basta realizar a seguinte configuração de acesso.

 
 mkdir -p $HOME/.kube

 oci ce cluster create-kubeconfig --cluster-id [cluster id] --file $HOME/.kube/config 
 


Feito isto, você poderá administrar remotamente seu Kubernetes cluster, inclusive definir um proxy de acesso local para o Kubernetes Dashboard.

 

 kubectl proxy
    
 http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/ 





Definindo o repositório de imagens Docker no Oracle OCIR


Será necessário definir um repositório para as imagens Docker à serem distribuídas no Oracle OKE. Para isso, basta acessar o dashboard do Oracle OCIR e solicitar a criação de um novo repositório. Basta definir o nome do repositório e definir se terá um acesso público ou privado.



Uma vez definido o repositório, ele estará pronto para receber as imagens do projeto para distribuição no Oracle OKE.

 



Configurando pipelines para o projeto MicroProfile no Oracle Wercker


Antes de configurar o pipeline de integração CI/CD é necessário subir o projeto em um repositório Git. Oracle Wercker já possui integração nativa com Github, Bitbucket, Gitlab ou Oracle Developer Cloud Service, mas você pode utilizar também qualquer repositório Git com acesso público na Internet. Para uma nova aplicação, basta seguir o passo-a-passo para criação de uma nova aplicação na página inicial do Oracle Wercker.

>



Após a criação da aplicação, é necessário definir o arquivo de configuração de pipelines wercker.xml. Neste arquivo será definido o workflow de pipelines a ser executado durante o fluxo de CI/CD.

    
#Use OpenJDK base docker image from dockerhub and open the application port on the 
docker container box:
  id: openjdk:8
  ports:
  - 8080

#Build our application using Maven, just as we always have
build:
  steps:
  - install-packages:
      packages: maven
  - script:
      name: maven build
      code: mvn clean package

#Build and push the docker image with our built and tested application to the Oracle 
Container Registry push-release:
  steps:
  - internal/docker-build:
      dockerfile: Dockerfile
      image-name: microprofile
  - internal/docker-push:
      username: $DOCKER_USERNAME
      password: $DOCKER_PASSWORD
      repository: $DOCKER_REPO
      registry: $DOCKER_REGISTRY
      image-name: microprofile
      tag: latest

#Deploy our container from the Oracle Container Registry to the Oracle Container Engine
deploy-to-cluster:
  box:
    id: alpine
    cmd: /bin/sh
  steps:
  - bash-template
  - script:
      name: "Visualise Kubernetes config"
      code: cat kubernetes.yml
  - kubectl:
      name: deploy to kubernetes
      server: $KUBERNETES_MASTER
      token: $KUBERNETES_TOKEN
      insecure-skip-tls-verify: true
      command: apply -f kubernetes.yml
    


Para o processo de distribuição da aplicação no cluster OKE, é necessário também definir o arquivo de descrição de deployment e serviço do Kubernetes. Este é um arquivo padronizado e serve para configurar um novo serviço de aplicação dentro do cluster.

    
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: microprofile
spec:
  selector:
    matchLabels:
      app: microprofile
  replicas: 1 # deployment runs 1 pods matching the template
  template: # create pods using pod definition in this template
    metadata:
      labels:
        app: microprofile
    spec:
      containers:
      - name: microprofile
        image: iad.ocir.io/rodrigocandidosilva/microprofile
        imagePullPolicy: Always
        ports:
        - name: microprofile
          containerPort: 8080 #Endpoint is at port 8080 in the container
          protocol: TCP
      imagePullSecrets:
      - name: wercker
---
apiVersion: v1
kind: Service
metadata:
  name: microprofile
  labels:
    app: microprofile
spec:
  type: LoadBalancer #Exposes the service
  ports:
  - port: 30000
    protocol: TCP
    targetPort: 8080
  selector:
    app: microprofile
---
    


Por fim, foram definidas algumas variáveis de ambiente para a completa execução dos pipelines. Você deve definir os valores de inicialização para estas variáveis por meio da configuração de ambiente no projeto definido no Oracle Wercker.

  • DOCKER_USERNAME: usuário com acesso ao repositório OCIR;
  • DOCKER_REGISTRY: endereço de registro do repositório OCIR;
  • DOCKER_REPO: nome do repositório de imagens do projeto definido no OCIR;
  • DOCKER_PASSWORD: token de autenticação para acesso ao repositório OCIR;
  • KUBERNETES_MASTER: endereço de acesso ao cluster OKE;
  • KUBERNETES_TOKEN: token de acesso ao cluster OKE;

 



Para geração do token de autenticação de acesso ao repositório OCIR, é necessário solicitar um novo token para um usuário definido no banco de identidades do Oracle Cloud.



Já a definição do token de acesso ao cluster Kubernetes, você pode verificá-lo a partir da configuração Kubeconfig realizada anteriormente. Basta acessar o arquivo ~/.kube/config localizado na sua máquina e buscar pela referência user token.



Para finalizar a configuração, será necessário definir os pipelines por meio do editor de workflow no Oracle Wercker. Para cada pipeline definido no arquivo wercker.yml anteriormente, será necessário adicionar um novo registro de pipeline.



E por fim, basta definir o fluxo do workflow representando a execução dos pipelines respeitando suas precedências.





Executando os pipelines e rodando a aplicação no cluster OKE


Por padrão, a execução dos pipelines serão executados por meio de qualquer modificação realizada no repositório Git definido (a partir do master branch). Mas, é possível também realizar manualmente a execução dos pipelines a partir da aba de execução no projeto definido no ambiente do Oracle Wercker.



Após a finalização completa e com sucesso dos pipelines, você poderá observar o resultado da execução, verificando a nova imagem Docker persistida no repositório OCIR...



... e também, a distribuição e execução da mesma no cluster OKE.



Para acessar a aplicação, basta verificar o endpoint externo definido pelo Kubernetes e então acessar as seguintes URLs:



O código fonte deste exemplo encontra-se disponível no Github e as configurações de pipeline encontram-se disponíveis neste projeto no Oracle Wercker.




Referências


https://microprofile.io/
https://thorntail.io/
https://thorntail.io/generator/
https://kubernetes.io/
https://www.oracle.com/cloud/container-native-platform/
https://www.oracle.com/webfolder/technetwork/tutorials/obe/oci/wercker/index.html
https://app.wercker.com
https://blogs.oracle.com/wercker/
https://docs.cloud.oracle.com/iaas/Content/Registry/Tasks/registrygettingauthtoken.htm
https://kubernetes.io/docs/reference/kubectl/overview/




Rodrigo Cândido da Silva @rcandidosilva
Consultor independente, Oracle Groundbreaker Ambassador e JUG Leader do GUJavaSC, grupo de usuários Java de Santa Catarina. Com mais de 18 anos de experiência na área de desenvolvimento de software, vem trabalhando atualmente nas áreas de consultoria, desenvolvimento, treinamento e design de arquiteturas de software. Contribuidor ativo de projetos open source e participante frequente em conferências de software pelo Brasil e pelo mundo. 

Este artigo foi revisto pela equipe de produtos Oracle e está em conformidade com as normas e práticas para o uso de produtos Oracle