Como fazer Deploy de Microserviços no OpenShift via CLI

O deploy de microserviços em ambientes orquestrados exige precisão, consistência e automação. Embora interfaces gráficas (GUIs) sejam úteis para visualização inicial, o gerenciamento eficiente de infraestrutura como código (IaC) depende fundamentalmente do uso da linha de comando. O OpenShift Container Platform, baseado em Kubernetes, oferece uma ferramenta de interface de linha de comando (CLI) robusta chamada oc, que permite aos engenheiros de DevOps e SREs automatizar o ciclo de vida completo dos seus contêineres.

Este tutorial guia você através do processo técnico de criação, configuração e deploy de um microserviço simples no OpenShift utilizando exclusivamente a CLI. O foco é demonstrar como transformar código em aplicações rodando na nuvem privada ou pública, seguindo as melhores práticas de DevOps e automação de infraestrutura.

1. Pré-requisitos e Instalação da CLI do OpenShift

Antes de iniciar o deploy, é fundamental garantir que o ambiente local esteja configurado corretamente. A ferramenta oc é o braço direito do administrador no terminal.

Instalando a Ferramenta OC

No Linux (distribuições baseadas em RPM ou DEB), utilize os gerenciadores de pacotes nativos ou baixe o binário diretamente. Para usuários macOS, o Homebrew é a opção padrão. Em sistemas Windows, certifique-se de que o caminho do executável esteja adicionado à variável de ambiente PATH.

Abaixo, exemplos de instalação para diferentes sistemas operacionais:

• Ubuntu/Debian: Baixe o pacote .deb e execute sudo dpkg -i openshift-client-linux-*.rpm (note que pode ser necessário converter ou usar o binário direto dependendo da versão).
• RHEL/CentOS/Fedora: Utilize sudo dnf install openshift-clients.
• macOS: Execute brew install openshift-cli.

Após a instalação, verifique a versão instalada para garantir a compatibilidade com o cluster:

oc version

Autenticação no Cluster

O próximo passo é conectar sua CLI ao cluster OpenShift. Você precisará das credenciais de administrador ou de um usuário com permissões suficientes para criar projetos (namespaces) e recursos.

oc login https://api.seu-cluster-openshift.com:6443 -u admin_user -p 'sua_senha_segura'

Se estiver usando tokens, substitua os parâmetros de usuário e senha por --token=SEU_TOKEN_AQUI. Uma conexão bem-sucedida retornará uma mensagem confirmando o contexto ativo.

2. Preparação do Ambiente: Namespace e Configuração Inicial

No OpenShift, os recursos são isolados dentro de Namespaces, que funcionam como projetos virtuais. Para fins de demonstração de microserviços, vamos criar um namespace dedicado.

Criando o Namespace

Evite usar o namespace padrão default. Crie um novo projeto para organizar suas aplicações:

oc new-project microservicos-app --description="Ambiente de testes para microserviços" --display-name="Microservices Dev"

O comando new-project não apenas cria o namespace, mas também configura as políticas de segurança (SCCs) padrão e credenciais para o usuário atual dentro desse contexto.

Criando uma Imagem Docker Base

Para este exemplo, utilizaremos um microserviço simples em Python que roda um servidor HTTP básico. Crie um arquivo chamado app.py:

from http.server import HTTPServer, BaseHTTPRequestHandler

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/plain')
        self.end_headers()
        self.wfile.write(b'Hello from OpenShift Microservice!\n')

server = HTTPServer(('0.0.0.0', 8080), Handler)
print('Serving on port 8080')
server.serve_forever()

Crie também um arquivo Dockerfile para definir como a imagem será construída:

FROM python:3.9-slim
WORKDIR /app
COPY app.py .
EXPOSE 8080
CMD ["python", "app.py"]

Construa a imagem localmente para testes iniciais (embora no OpenShift o ideal seja usar o BuildConfig, aqui demonstraremos o fluxo básico de deploy via CLI com uma imagem pré-construída ou usando o registry integrado):

docker build -t microservico-demo:v1 .

3. Deploy do Microserviço: Pods e Services

O OpenShift abstrai muitos conceitos do Kubernetes puro, mas entender a hierarquia de recursos é crucial para o troubleshooting. Um Pod é a unidade mínima de deploy, enquanto um Service expõe esse pod na rede.

Método 1: Deploy via Manifesto YAML (Recomendado para IaC)

A prática mais sólida em ambientes profissionais é definir os recursos em arquivos YAML. Crie o arquivo deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: microservico-api
  labels:
    app: microservico-api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: microservico-api
  template:
    metadata:
      labels:
        app: microservico-api
    spec:
      containers:
      - name: api-container
        image: docker.io/usuario/microservico-demo:v1
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: microservico-api-service
spec:
  selector:
    app: microservico-api
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: ClusterIP

Para aplicar essa configuração ao cluster, utilize o comando apply. Este comando é idempotente; se o recurso já existir, ele será atualizado.

oc apply -f deployment.yaml

O output deve confirmar a criação do Deployment e do Service:

deployment.apps/microservico-api created
service/microservico-api-service created

Método 2: Deploy Rápido via Comando Único (Imperativo)

Para cenários de emergência ou testes rápidos, a CLI permite criar recursos sem arquivos externos. Isso é útil para validar configurações antes de codificá-las em YAML.

oc run microservico-api --image=docker.io/usuario/microservico-demo:v1 --port=8080 --env="ENVIRONMENT=production"

Em seguida, exponha o serviço:

oc expose deployment/microservico-api

4. Verificação e Monitoramento do Deploy

Após submeter os recursos, é vital verificar se os pods estão em estado Running. No OpenShift, a saúde da aplicação é monitorada constantemente.

Verificando o Status dos Pods

oc get pods -l app=microservico-api

O resultado esperado será semelhante a:

NAME                             READY   STATUS    RESTARTS   AGE
microservico-api-6d4f5b8c9-x2k7l 1/1     Running   0          2m
microservico-api-6d4f5b8c9-p9m3n 1/1     Running   0          2m

Note que o label -l app=microservico-api filtra os resultados, mostrando apenas os pods pertencentes a essa aplicação específica.

Acessando os Logs em Tempo Real

Se houver erros de inicialização ou falhas na aplicação, os logs são o primeiro local de investigação. Utilize logs -f para seguir (follow) o output do terminal:

oc logs -f deployment/microservico-api

Isso permite visualizar as saídas do console do Python, incluindo erros de conexão a bancos de dados ou falhas de configuração.

5. Expondo o Serviço para Acesso Externo (Route)

No Kubernetes padrão, utiliza-se Ingress e serviços do tipo LoadBalancer. No OpenShift, a abstração chamada Route simplifica a exposição de aplicações para fora do cluster, gerenciando automaticamente o TLS/SSL (HTTPS) se configurado.

Criando a Route

Para tornar o microserviço acessível via URL pública dentro do domínio do OpenShift:

oc create route edge --service=microservico-api-service --insecure-policy=Redirect

A flag --insecure-policy=Redirect garante que todas as requisições HTTP sejam redirecionadas para HTTPS, uma exigência de segurança moderna.

Obtendo a URL

oc get routes

O output mostrará a URL externa:

NAME                   HOST/PORT                                                PATH   SERVICES                 PORT    TERMINATION   WILDCARD
microservico-api-service   microservico-api-microservicos-app.apps.seu-cluster.com          microservico-api-service   80      edge/Redirect   None

Você pode testar o acesso diretamente pelo navegador ou via curl:

curl -k https://microservico-api-microservicos-app.apps.seu-cluster.com

O retorno deve ser: Hello from OpenShift Microservice!

6. Atualizações e Rollbacks (DevOps na Prática)

A capacidade de atualizar aplicações sem downtime é o cerne da automação DevOps. No OpenShift, isso é feito alterando a imagem do container no Deployment.

Rolagem de Nova Versão

Suponha que você tenha construído uma nova versão v2 da sua imagem. Para atualizar o deploy:

oc set image deployment/microservico-api api-container=docker.io/usuario/microservico-demo:v2

O OpenShift iniciará automaticamente novos pods com a versão 2 e terminará os antigos gradualmente, garantindo zero downtime durante a transição.

Verificando o Histórico de Rollouts

Para auditar mudanças ou reverter caso haja falha na nova versão:

oc rollout status deployment/microservico-api

Caso seja necessário voltar à versão anterior:

oc rollout undo deployment/microservico-api

7. Limpeza do Ambiente

Boas práticas de infraestrutura recomendam a remoção de recursos não utilizados para economizar recursos computacionais e manter o cluster limpo.

oc delete project microservicos-app

Este comando remove todos os recursos (Pods, Services, Routes, ConfigMaps) associados ao namespace microservicos-app.

Conclusão

O uso da CLI do OpenShift (oc) proporciona controle granular e automação essencial para equipes de engenharia modernas. Ao dominar os comandos de deploy, exposição e monitoramento apresentados neste tutorial, profissionais de TI podem integrar o OpenShift em pipelines CI/CD complexos, garantindo escalabilidade e resiliência para suas aplicações de microserviços.

Lembre-se: a infraestrutura como código e a automação são pilares da estabilidade. Utilize arquivos YAML versionados no Git para reprodutibilidade e reserve os comandos imperativos para debugging e testes rápidos.