Visão Geral

Este Curso Workshop Desenvolvendo Plugins para Rundeck, intensivo é voltado para desenvolvedores, engenheiros de automação e profissionais de DevOps que desejam estender as funcionalidades nativas do Rundeck, integrando-o profundamente com sistemas e processos específicos de suas organizações. Do ponto de vista técnico, você aprenderá os fundamentos da arquitetura de plugins do Rundeck e desenvolverá, passo a passo, diferentes tipos de plugins utilizando Java e/ou Groovy. Cobriremos desde plugins simples (como Node Steps e Workflow Steps) até tipos mais avançados (como Node Executors e Resource Model Sources), focando na interação com APIs externas, tratamento de dados e empacotamento para deployment. O formato de workshop garante que a maior parte do tempo seja dedicada à codificação e à resolução de problemas práticos.

Curso Workshop Desenvolvendo Plugins para Rundeck, a capacidade de desenvolver plugins customizados para o Rundeck desbloqueia um nível superior de automação e integração. Isso permite que as empresas adaptem o Rundeck às suas necessidades exatas, otimizando fluxos de trabalho que antes dependiam de scripts complexos ou integrações manuais. A customização resulta em maior eficiência operacional, redução de dependências de ferramentas externas e a consolidação de automações em uma única plataforma, o que representa um ganho significativo em agilidade, segurança e governança de TI. Profissionais com essa habilidade são capazes de criar soluções altamente customizadas que impulsionam a inovação e a eficiência.

Objetivo

Ao final do Curso Workshop Desenvolvendo Plugins para Rundeck, você será capaz de:

• Compreender a arquitetura e os pontos de extensão (SPIs) dos plugins do Rundeck.
• Configurar um ambiente de desenvolvimento para plugins Rundeck.
• Desenvolver e empacotar Node Step Plugins para ações customizadas em nós.
• Desenvolver e empacotar Workflow Step Plugins para lógica de negócio em Workflows.
• Desenvolver Node Executor Plugins para métodos de execução de comandos alternativos.
• Desenvolver Resource Model Source Plugins para descoberta dinâmica de nós de fontes externas.
• Gerenciar dependências e empacotar plugins como JARs para deployment no Rundeck.
• Realizar o troubleshooting de plugins customizados.
• Explorar a documentação oficial para outros tipos de plugins.

Publico Alvo

• Desenvolvedores: Que querem estender suas habilidades para automação e plataformas de orquestração.
• Engenheiros de Automação/DevOps: Que precisam integrar o Rundeck com ferramentas proprietárias ou processos internos.
• Arquitetos de Soluções: Que precisam entender a extensibilidade do Rundeck para projetar soluções customizadas.
• Profissionais com experiência em Rundeck que desejam ir além da configuração e começar a programar suas próprias extensões.

Pre-Requisitos

• Conhecimento sólido de programação em Java e/ou Groovy. É o pré-requisito mais crítico, pois o desenvolvimento será focado nessas linguagens.
• Experiência prática com Rundeck (equivalente ao curso "Rundeck Essencial" ou "Avançado").
• Familiaridade com Apache Maven ou Gradle para gerenciamento de projetos Java/Groovy.
• Conhecimento básico de APIs REST e JSON/XML.
• Familiaridade com o uso da linha de comando Linux.

Materiais

Conteúdo Programatico

Módulo 1: Fundamentos da Arquitetura de Plugins do Rundeck (4 horas)

• 1.1. Visão Geral da Extensibilidade do Rundeck:
  • Por que desenvolver plugins? Cenários de uso e benefícios.
  • A arquitetura modular do Rundeck e os Service Provider Interfaces (SPIs).
  • Tipos de Plugins do Rundeck (Node Step, Workflow Step, Node Executor, Resource Model Source, Notification, Loggers, etc.).
• 1.2. Configurando o Ambiente de Desenvolvimento:
  • Instalação e configuração de JDK, Maven/Gradle e IDE.
  • Estrutura de um projeto de plugin Rundeck.
  • Dependências essenciais do Rundeck para desenvolvimento.
  • Exemplo "Hello World": Criando e empacotando um plugin simples.
• 1.3. Deployment e Teste de Plugins:
  • Diretórios de deployment de plugins no servidor Rundeck.
  • Instalação manual de plugins (.jar).
  • Verificação da instalação e logs de inicialização do Rundeck.
• Prática: Configurar o ambiente de desenvolvimento. Criar um projeto Maven/Gradle para um plugin Rundeck. Desenvolver e empacotar um plugin "Hello World" e fazer o deployment no Rundeck de testes.

Módulo 2: Desenvolvendo Node Step e Workflow Step Plugins (4 horas)

• 2.1. Node Step Plugins:
  • Anatomia de um Node Step Plugin (interfaces, anotações).
  • Obtendo parâmetros de Job e informações do Node.
  • Executando comandos e interagindo com o sistema operacional no nó.
  • Retornando resultados e logs para o Rundeck.
• 2.2. Workflow Step Plugins:
  • Diferenças entre Node Step e Workflow Step (execução no servidor Rundeck vs. no nó).
  • Cenários de uso para Workflow Step Plugins (integração com APIs externas, lógica de negócio).
  • Exemplo prático: Plugin que faz uma chamada a uma API REST e processa a resposta.
• Prática: Desenvolver um Node Step Plugin que execute um comando customizado no nó e retorne o output. Desenvolver um Workflow Step Plugin que faça uma chamada simples a uma API externa (ex: um serviço público REST). Empacotar e testar ambos.

Módulo 3: Desenvolvendo Node Executor e Resource Model Source Plugins (4 horas)

• 3.1. Node Executor Plugins:
  • Quando usar um Node Executor Plugin (alternativas ao SSH, WinRM).
  • Interface NodeExecutor e métodos essenciais.
  • Exemplo: Desenvolver um Node Executor básico que utilize um método de conexão alternativo (ex: Docker exec, ou um wrapper customizado).
• 3.2. Resource Model Source Plugins:
  • A importância da descoberta dinâmica de nós em ambientes de nuvem/mutáveis.
  • Interface ResourceModelSource e o formato de saída dos dados (XML/YAML/JSON).
  • Exemplo: Desenvolver um plugin que descubra hosts de um arquivo CSV ou de uma API interna simulada.
  • Filtragem e adição de atributos aos nós.
• Prática: Desenvolver um Node Executor Plugin simples. Desenvolver um Resource Model Source Plugin que leia hosts de um arquivo customizado e os adicione ao Rundeck.

Módulo 4: Gerenciamento Avançado, Troubleshooting e Próximos Passos (4 horas)

• 4.1. Gerenciamento de Dependências e Empacotamento:
  • Melhores práticas para gerenciamento de dependências (pom.xml no Maven, build.gradle no Gradle).
  • Empacotamento final do plugin como um JAR executável.
• 4.2. Tratamento de Erros, Logs e Troubleshooting:
  • Implementando tratamento de exceções robusto nos plugins.
  • Logging dentro do plugin para depuração (Rundeck logging API).
  • Utilizando logs do Rundeck para diagnosticar problemas de plugin.
• 4.3. Explorando Outros Tipos de Plugins e Boas Práticas:
  • Visão geral de outros tipos de plugins (Notification Plugins, Log Filter Plugins, Remote Script Node Steps).
  • Documentação oficial do Rundeck para desenvolvimento de plugins.
  • Contribuição para a comunidade e melhores práticas de código.
• Prática: Adicionar tratamento de erros e logging aos plugins desenvolvidos. Resolver um problema simulado em um plugin. Discussão aberta sobre ideias de plugins dos participantes.