DEV Community: Jhonathan dos reis

Separation of Concerns em Java: O Jeito Simples

Jhonathan dos reis — Mon, 15 Sep 2025 17:19:08 +0000

É difícil aceitar a verdade. Que sua aplicação Java com mais de 2000 linhas está toda escrita em uma única classe... mas você já sabe disso, ou pelo menos espero que saiba. Eu sei que você já tentou torná-la mais compacta, mas as coisas simplesmente não estão fazendo sentido.

É aqui que entra um princípio que transcende tempo e espaço, que nos ajuda em todos os aspectos da nossa vida: Separation of Concerns (Separação de Responsabilidades) ou SoC.

Eu sei que pode parecer intimidante, mas não se preocupe - o Tio T está aqui e vou tornar tudo o mais simples possível para o seu prazer.

Então hoje vamos passar por estes pontos:

O que é Separation of Concerns?
Coesão e Acoplamento
Por que funciona?
Exemplos práticos em Java
Conclusão

Antes de começarmos, fique confortável, pegue sua bebida favorita e coloque seus óculos inteligentes. Vamos começar!

O que é Separation of Concerns?

Como todo bom post técnico precisa de uma citação, aqui está algo que copiei da Wikipedia:

"Em ciência da computação, separation of concerns é um princípio de design para separar um programa de computador em seções distintas, de modo que cada seção aborde uma preocupação separada."

Ok, agora que as formalidades acabaram, deixe-me explicar de forma simples.

Separation of Concerns é um princípio universal que praticamente todas as pessoas aplicam. Não estou falando apenas de desenvolvimento de software - ele se aplica a muitos outros campos também.

Um Exemplo do Mundo Real

Imagine sua cozinha. Você não guarda talheres no mesmo lugar que produtos de limpeza, certo? Você tem gavetas separadas para:

Talheres
Panelas
Temperos
Produtos de limpeza

Por quê? Porque cada categoria tem uma responsabilidade diferente, e misturá-las tornaria sua vida um caos.

Como SoC se Aplica ao Java?

Em Java, aplicamos SoC em vários níveis:

1. Nível de Arquitetura - Padrão MVC

// Model - Responsável pelos dados
public class Usuario {
    private Long id;
    private String nome;
    private String email;

    // getters e setters
}

// View - Responsável pela apresentação (JSP exemplo)
<%@ page contentType="text/html;charset=UTF-8" %>
<html>
<body>
    <h1>Bem-vindo, ${usuario.nome}!</h1>
</body>
</html>

// Controller - Responsável pela lógica de controle
@RestController
@RequestMapping("/usuarios")
public class UsuarioController {
    @Autowired
    private UsuarioService service;

    @GetMapping("/{id}")
    public Usuario buscarUsuario(@PathVariable Long id) {
        return service.buscarPorId(id);
    }
}

2. Nível de Camadas - Arquitetura em Camadas

// Camada de Apresentação
@RestController
public class PedidoController {
    @Autowired
    private PedidoService pedidoService;

    @PostMapping("/pedidos")
    public ResponseEntity<Pedido> criarPedido(@RequestBody PedidoDTO dto) {
        Pedido pedido = pedidoService.processar(dto);
        return ResponseEntity.ok(pedido);
    }
}

// Camada de Negócio
@Service
public class PedidoService {
    @Autowired
    private PedidoRepository repository;
    @Autowired
    private EmailService emailService;

    public Pedido processar(PedidoDTO dto) {
        // Lógica de negócio
        Pedido pedido = new Pedido(dto);
        pedido.calcularTotal();
        pedido = repository.save(pedido);
        emailService.enviarConfirmacao(pedido);
        return pedido;
    }
}

// Camada de Dados
@Repository
public interface PedidoRepository extends JpaRepository<Pedido, Long> {
    List<Pedido> findByClienteId(Long clienteId);
}

Coesão e Acoplamento

Dois conceitos fundamentais em SoC:

Alta Coesão (BOM ✅)

Elementos relacionados ficam juntos.

// ALTA COESÃO - Todos os métodos são sobre gerenciamento de conta
public class ContaBancaria {
    private BigDecimal saldo;
    private String numero;

    public void depositar(BigDecimal valor) {
        this.saldo = this.saldo.add(valor);
    }

    public void sacar(BigDecimal valor) {
        if (saldo.compareTo(valor) >= 0) {
            this.saldo = this.saldo.subtract(valor);
        }
    }

    public BigDecimal consultarSaldo() {
        return this.saldo;
    }
}

Baixo Acoplamento (BOM ✅)

Módulos dependem minimamente uns dos outros.

// BAIXO ACOPLAMENTO - Usando interfaces
public interface NotificadorService {
    void enviar(String mensagem, String destinatario);
}

@Service
public class EmailNotificador implements NotificadorService {
    public void enviar(String mensagem, String destinatario) {
        // Implementação de email
    }
}

@Service
public class SMSNotificador implements NotificadorService {
    public void enviar(String mensagem, String destinatario) {
        // Implementação de SMS
    }
}

// A classe não está acoplada a uma implementação específica
@Service
public class PedidoService {
    @Autowired
    private NotificadorService notificador; // Interface, não implementação!

    public void finalizarPedido(Pedido pedido) {
        // processar pedido...
        notificador.enviar("Pedido confirmado!", pedido.getCliente().getEmail());
    }
}

Por Que SoC Funciona?

1. Manutenibilidade 🔧

Quando você precisa fazer uma mudança, você sabe exatamente onde ir:

// Antes de SoC - Tudo misturado 😱
public class SistemaPedido {
    public void processarPedido(String item, int quantidade, String email) {
        // Validação
        if (item == null || quantidade <= 0) {
            throw new IllegalArgumentException("Dados inválidos");
        }

        // Cálculo de preço
        double preco = quantidade * 10.0;
        if (quantidade > 100) {
            preco = preco * 0.9; // desconto
        }

        // Salvar no banco
        Connection conn = DriverManager.getConnection("jdbc:...");
        PreparedStatement stmt = conn.prepareStatement("INSERT INTO pedidos...");
        // ...

        // Enviar email
        Properties props = new Properties();
        Session session = Session.getInstance(props);
        MimeMessage message = new MimeMessage(session);
        // ...
    }
}

// Depois de SoC - Tudo organizado 😊
@Service
public class PedidoService {
    @Autowired private ValidadorPedido validador;
    @Autowired private CalculadoraPreco calculadora;
    @Autowired private PedidoRepository repository;
    @Autowired private EmailService emailService;

    public void processarPedido(PedidoDTO dto) {
        validador.validar(dto);
        BigDecimal preco = calculadora.calcular(dto);
        Pedido pedido = new Pedido(dto, preco);
        repository.save(pedido);
        emailService.enviarConfirmacao(pedido);
    }
}

2. Testabilidade 🧪

Com SoC, testar fica muito mais fácil:

@Test
public void testCalculadoraPreco() {
    CalculadoraPreco calc = new CalculadoraPreco();
    PedidoDTO dto = new PedidoDTO("Item", 150);

    BigDecimal preco = calc.calcular(dto);

    // Testando apenas a lógica de cálculo, isoladamente!
    assertEquals(new BigDecimal("1350.00"), preco); // 150 * 10 * 0.9
}

@Test
public void testPedidoService() {
    // Usando mocks para isolar o teste
    ValidadorPedido validador = mock(ValidadorPedido.class);
    CalculadoraPreco calculadora = mock(CalculadoraPreco.class);
    PedidoRepository repository = mock(PedidoRepository.class);
    EmailService emailService = mock(EmailService.class);

    when(calculadora.calcular(any())).thenReturn(new BigDecimal("100"));

    PedidoService service = new PedidoService(validador, calculadora, repository, emailService);
    service.processarPedido(new PedidoDTO());

    verify(repository).save(any());
    verify(emailService).enviarConfirmacao(any());
}

3. Reutilização ♻️

Componentes bem separados podem ser reutilizados:

// Este serviço de email pode ser usado em qualquer lugar!
@Service
public class EmailService {
    public void enviar(Email email) {
        // implementação
    }
}

// Usado no PedidoService
@Service
public class PedidoService {
    @Autowired EmailService emailService;
    // ...
}

// Usado no UsuarioService também!
@Service 
public class UsuarioService {
    @Autowired EmailService emailService;
    // ...
}

Exemplos Práticos do Mundo Java

Exemplo 1: Sistema de E-commerce

// ❌ RUIM - Violando SoC
public class Produto {
    private String nome;
    private BigDecimal preco;

    // Métodos de negócio - OK
    public BigDecimal calcularPrecoComDesconto(BigDecimal percentual) {
        return preco.multiply(BigDecimal.ONE.subtract(percentual));
    }

    // Método de persistência - NÃO DEVERIA ESTAR AQUI!
    public void salvarNoBanco() {
        Connection conn = DriverManager.getConnection("...");
        // código SQL...
    }

    // Método de apresentação - NÃO DEVERIA ESTAR AQUI!
    public String toHTML() {
        return "<div>" + nome + " - R$ " + preco + "</div>";
    }
}

// ✅ BOM - Respeitando SoC
public class Produto {
    private String nome;
    private BigDecimal preco;

    // Apenas lógica de negócio
    public BigDecimal calcularPrecoComDesconto(BigDecimal percentual) {
        return preco.multiply(BigDecimal.ONE.subtract(percentual));
    }
}

@Repository
public class ProdutoRepository {
    public void salvar(Produto produto) {
        // código de persistência
    }
}

@Component
public class ProdutoView {
    public String renderizar(Produto produto) {
        return "<div>" + produto.getNome() + " - R$ " + produto.getPreco() + "</div>";
    }
}

Exemplo 2: Processamento de Pagamento

// Separando responsabilidades em um sistema de pagamento

// 1. Validação
@Component
public class ValidadorPagamento {
    public void validar(DadosPagamento dados) {
        if (dados.getValor().compareTo(BigDecimal.ZERO) <= 0) {
            throw new ValorInvalidoException();
        }
        if (!isCartaoValido(dados.getNumeroCartao())) {
            throw new CartaoInvalidoException();
        }
    }

    private boolean isCartaoValido(String numero) {
        // Algoritmo de Luhn
        return true; // simplificado
    }
}

// 2. Processamento
@Component
public class ProcessadorPagamento {
    @Autowired
    private GatewayPagamento gateway;

    public RespostaPagamento processar(DadosPagamento dados) {
        return gateway.cobrar(dados);
    }
}

// 3. Notificação
@Component
public class NotificadorPagamento {
    @Autowired
    private EmailService emailService;
    @Autowired
    private SMSService smsService;

    public void notificarSucesso(Pagamento pagamento) {
        emailService.enviar(criarEmailSucesso(pagamento));
        if (pagamento.getCliente().temCelular()) {
            smsService.enviar(criarSMSSucesso(pagamento));
        }
    }
}

// 4. Orquestração
@Service
public class PagamentoService {
    @Autowired private ValidadorPagamento validador;
    @Autowired private ProcessadorPagamento processador;
    @Autowired private NotificadorPagamento notificador;
    @Autowired private PagamentoRepository repository;

    @Transactional
    public Pagamento realizarPagamento(DadosPagamento dados) {
        // Cada componente faz sua parte
        validador.validar(dados);
        RespostaPagamento resposta = processador.processar(dados);
        Pagamento pagamento = new Pagamento(dados, resposta);
        repository.save(pagamento);
        notificador.notificarSucesso(pagamento);
        return pagamento;
    }
}

SoC em Diferentes Níveis

Nível de Método

// ❌ RUIM - Método fazendo muitas coisas
public void processarRelatorio(List<Venda> vendas) {
    // Filtrar vendas
    List<Venda> vendasValidas = new ArrayList<>();
    for (Venda v : vendas) {
        if (v.getValor() > 0 && v.getData() != null) {
            vendasValidas.add(v);
        }
    }

    // Calcular total
    BigDecimal total = BigDecimal.ZERO;
    for (Venda v : vendasValidas) {
        total = total.add(v.getValor());
    }

    // Formatar relatório
    StringBuilder sb = new StringBuilder();
    sb.append("Relatório de Vendas\n");
    sb.append("Total: ").append(total).append("\n");

    // Salvar arquivo
    Files.write(Paths.get("relatorio.txt"), sb.toString().getBytes());

    // Enviar email
    emailService.enviar("relatorio@empresa.com", sb.toString());
}

// ✅ BOM - Cada método com uma responsabilidade
public void processarRelatorio(List<Venda> vendas) {
    List<Venda> vendasValidas = filtrarVendasValidas(vendas);
    BigDecimal total = calcularTotal(vendasValidas);
    String relatorio = formatarRelatorio(vendasValidas, total);
    salvarRelatorio(relatorio);
    enviarRelatorioPorEmail(relatorio);
}

private List<Venda> filtrarVendasValidas(List<Venda> vendas) {
    return vendas.stream()
        .filter(v -> v.getValor().compareTo(BigDecimal.ZERO) > 0)
        .filter(v -> v.getData() != null)
        .collect(Collectors.toList());
}

private BigDecimal calcularTotal(List<Venda> vendas) {
    return vendas.stream()
        .map(Venda::getValor)
        .reduce(BigDecimal.ZERO, BigDecimal::add);
}

private String formatarRelatorio(List<Venda> vendas, BigDecimal total) {
    return String.format("Relatório de Vendas\nTotal: %s\nQuantidade: %d", 
                        total, vendas.size());
}

Nível de Pacotes

com.empresa.app/
├── controller/      # Responsável por receber requisições
│   ├── UsuarioController.java
│   └── ProdutoController.java
├── service/         # Lógica de negócio
│   ├── UsuarioService.java
│   └── ProdutoService.java
├── repository/      # Acesso a dados
│   ├── UsuarioRepository.java
│   └── ProdutoRepository.java
├── model/          # Entidades do domínio
│   ├── Usuario.java
│   └── Produto.java
├── dto/            # Objetos de transferência
│   ├── UsuarioDTO.java
│   └── ProdutoDTO.java
└── util/           # Utilitários
    ├── EmailUtil.java
    └── ValidadorUtil.java

Aplicando SoC com Spring Boot

Spring Boot naturalmente encoraja SoC através de suas anotações:

@Configuration  // Configuração separada
public class AppConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Component      // Componente reutilizável
public class CacheManager {
    private Map<String, Object> cache = new HashMap<>();
    // ...
}

@Service        // Lógica de negócio
public class ClienteService {
    // ...
}

@Repository     // Acesso a dados
public interface ClienteRepository extends JpaRepository<Cliente, Long> {
    // ...
}

@RestController // Controlador REST
public class ClienteController {
    // ...
}

@Aspect         // Aspectos transversais (logging, segurança)
@Component
public class LoggingAspect {
    @Around("@annotation(Loggable)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long executionTime = System.currentTimeMillis() - start;
        logger.info("{} executed in {} ms", joinPoint.getSignature(), executionTime);
        return proceed;
    }
}

Padrões de Design que Implementam SoC

1. Strategy Pattern

// Separando algoritmos de cálculo de frete
public interface CalculadoraFrete {
    BigDecimal calcular(Pedido pedido);
}

@Component
public class FretePAC implements CalculadoraFrete {
    public BigDecimal calcular(Pedido pedido) {
        return pedido.getPeso().multiply(new BigDecimal("5.00"));
    }
}

@Component
public class FreteSedex implements CalculadoraFrete {
    public BigDecimal calcular(Pedido pedido) {
        return pedido.getPeso().multiply(new BigDecimal("15.00"));
    }
}

@Service
public class FreteService {
    private Map<TipoFrete, CalculadoraFrete> calculadoras;

    public BigDecimal calcularFrete(Pedido pedido, TipoFrete tipo) {
        return calculadoras.get(tipo).calcular(pedido);
    }
}

2. Observer Pattern

// Separando notificações de eventos
public interface EventListener {
    void onPedidoCriado(Pedido pedido);
}

@Component
public class EmailListener implements EventListener {
    public void onPedidoCriado(Pedido pedido) {
        // Enviar email
    }
}

@Component
public class EstoqueListener implements EventListener {
    public void onPedidoCriado(Pedido pedido) {
        // Atualizar estoque
    }
}

@Component
public class NotaFiscalListener implements EventListener {
    public void onPedidoCriado(Pedido pedido) {
        // Gerar nota fiscal
    }
}

@Service
public class PedidoService {
    @Autowired
    private List<EventListener> listeners;

    public void criarPedido(PedidoDTO dto) {
        Pedido pedido = new Pedido(dto);
        // salvar pedido...

        // Notificar todos os interessados
        listeners.forEach(l -> l.onPedidoCriado(pedido));
    }
}

Microserviços: SoC em Escala

// Serviço de Usuários
@SpringBootApplication
public class UserServiceApplication {
    // Responsável apenas por usuários
}

// Serviço de Pedidos
@SpringBootApplication
public class OrderServiceApplication {
    // Responsável apenas por pedidos
}

// Serviço de Notificações
@SpringBootApplication
public class NotificationServiceApplication {
    // Responsável apenas por notificações
}

// Comunicação via REST ou mensageria
@FeignClient(name = "user-service")
public interface UserServiceClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable Long id);
}

Armadilhas Comuns e Como Evitá-las

1. God Class (Classe Deus)

// ❌ RUIM - Classe fazendo tudo
public class SistemaCompleto {
    // 50 atributos
    // 100 métodos
    // Validação, cálculo, persistência, apresentação...
}

// ✅ BOM - Responsabilidades distribuídas
public class Usuario { /* modelo */ }
public class UsuarioService { /* lógica */ }
public class UsuarioRepository { /* persistência */ }
public class UsuarioController { /* API */ }

2. Anemic Domain Model

// ⚠️ CUIDADO - Modelo anêmico (sem comportamento)
public class Conta {
    private BigDecimal saldo;
    // apenas getters e setters
}

public class ContaService {
    public void sacar(Conta conta, BigDecimal valor) {
        // toda lógica aqui
    }
}

// ✅ MELHOR - Modelo rico
public class Conta {
    private BigDecimal saldo;

    public void sacar(BigDecimal valor) {
        if (valor.compareTo(saldo) > 0) {
            throw new SaldoInsuficienteException();
        }
        this.saldo = saldo.subtract(valor);
    }

    public void depositar(BigDecimal valor) {
        this.saldo = saldo.add(valor);
    }
}

Conclusão

Separation of Concerns não é apenas um princípio teórico - é uma ferramenta prática que torna nosso código:

Mais fácil de entender 🧠
Mais fácil de manter 🔧
Mais fácil de testar 🧪
Mais fácil de escalar 📈
Mais fácil de reutilizar ♻️

Lembre-se:

Cada classe deve ter uma razão para mudar
Cada método deve fazer uma coisa bem feita
Cada camada deve ter uma responsabilidade clara
Prefira composição sobre herança
Use interfaces para reduzir acoplamento

Próximos Passos

Estude os princípios SOLID (SoC é parte do S - Single Responsibility)
Explore padrões de design como MVC, MVP, MVVM
Pratique Domain-Driven Design (DDD)
Aprenda sobre Arquitetura Hexagonal
Experimente com Microserviços

Call to Action

Agora olhe para seu código Java. Encontre aquela classe com 1000 linhas. Você sabe qual é.

Comece pequeno:

Extraia um método
Depois extraia uma classe
Depois separe em camadas
Continue refatorando

Roma não foi construída em um dia, e seu código limpo também não será. Mas cada passo na direção certa conta!

💬 Tem alguma dúvida ou quer compartilhar como aplica SoC em seus projetos Java? Deixe um comentário abaixo!

⭐ Se este artigo foi útil, não esqueça de dar uma estrela e compartilhar com seus colegas desenvolvedores Jav

Configurando o Keycloak com SSL e integração ao banco de dados PostgreSQL

Jhonathan dos reis — Fri, 14 Apr 2023 23:50:25 +0000

Neste guia, você encontrará instruções detalhadas passo a passo para configurar e executar um servidor Keycloak, com suporte completo para SSL direcionado ao host, sem a necessidade de um proxy reverso como o Nginx.

Antecedentes e Escopo

Encontrar informações atualizadas sobre tecnologias em constante evolução, como o Keycloak, pode ser um desafio, mesmo após pesquisar em fóruns, blogs e Stack Overflow. O autor deste artigo relata que não encontrou referências específicas para a versão estável 20.0.5, mas sim apenas para versões antigas. No entanto, após validar as informações contidas na documentação oficial, este artigo foi elaborado para fornecer um guia completo e atualizado sobre como configurar o Keycloak. As instruções foram testadas e comprovadas, garantindo um resultado bem-sucedido ao seguir os passos descritos.

Além das instruções genéricas para configurar o Keycloak, este artigo fornece instruções detalhadas e passo a passo para integrar o SafeNet Keycloak Agent com o servidor Keycloak. Isso inclui o módulo e o tema de login do SafeNet Authentication Service, oferecendo uma solução completa e segura para os usuários.
O objetivo principal dessas instruções é facilitar a configuração e reduzir o tempo necessário para criar uma demonstração, prova de conceito (PoC). Isso é alcançado fornecendo um guia completo e atualizado, com instruções detalhadas e passo a passo, testadas e comprovadas para garantir um resultado bem-sucedido.

Pré-requisitos

Os seguintes pré-requisitos devem ser atendidos para seguir com êxito estas instruções:

Ubuntu 20.04
DNS (FQDN resolvível)
Regras de FW/rede:
22 (SSH)
443 (SSL/TLS)
80 (HTTP)

Geração de certificado com Lets Encrypt

No host do Keycloak Server de destino, execute as seguintes etapas:

1- SSH para o host Keycloak Server

2- Execute o seguinte comando para instalar o Letsencrypt Certbot:

sudo snap install --classic certbot

3- Em seguida, execute o seguinte comando para garantir que o comando certbot agora possa ser executado:

sudo ln -s /snap/bin/certbot /usr/bin/certbot

4- Agora execute o Certbot para iniciar a geração do certificado:

sudo certbot certonly --standalone

Siga as instruções na tela para gerar um certificado SSL/TLS e uma chave privada.

Agora você tem um arquivo fullchain.pem e um privkey.pem para usar com SSL/TLS

Instalar e configurar o Docker

O modelo abaixo apresenta os comandos necessários para instalar a versão mais recente do Docker Engine. Certifique-se de verificar se há atualizações na documentação oficial antes de executar os comandos.

1- Abra um terminal e atualize o índice de pacotes do apt:

sudo apt update

2- Instale o Docker:

sudo apt install docker.io

3- Verifique se o Docker foi instalado corretamente executando o seguinte comando:

docker --version

4- Inicie o serviço do Docker:

sudo systemctl start docker

5- Verifique o status do serviço Docker para garantir que ele esteja em execução:

sudo systemctl status docker

6- (Opcional) Para permitir que o Docker seja iniciado automaticamente na inicialização do sistema, execute o seguinte comando:

sudo systemctl enable docker

Instalar o Docker Compose

Como etapa final da instalação/configuração do Docker, instalamos o Docker Compose.

1- Verifique se o Docker está instalado e em execução. Você pode verificar isso executando o seguinte comando:

sudo docker version

2- Faça o download da versão mais recente do Docker Compose:

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

3- Defina as permissões de execução para o binário do Docker Compose:

sudo chmod +x /usr/local/bin/docker-compose

4- Verifique se a instalação foi bem-sucedida executando o seguinte comando:

docker-compose --version

5- Para iniciar o Docker Compose, execute o seguinte comando:

sudo systemctl start docker-compose

6- Para habilitar o Docker Compose na inicialização do sistema, execute o seguinte comando:

sudo systemctl enable docker-compose

7- Para verificar o status do Docker Compose, execute o seguinte comando:

sudo systemctl status docker-compose

Pré-configuração do servidor Keycloak

Após gerar os certificados e instalar e verificar o Docker, o próximo passo é mover ou manter os arquivos de certificado e outras configurações adicionais, como o tema SafeNet ou um tema personalizado, além de quaisquer plug-ins ou módulos, para os diretórios apropriados onde possam ser acessados quando a solução for executada.

1- Copie os .pem arquivos de certificado para um local onde possam ser lidos pelo Docker/Docker-Compose (observe o exemplo abaixo)

2- Defina e teste as permissões para o arquivo acima para garantir que eles possam ser acessados:

sudo chmod 655 ./certs/*

Exemplos de arquivos e estrutura de arquivos

Aqui está um exemplo de estrutura de arquivo que mostra a localização dos arquivos de certificado fullchain.pem, chave privkey.pem, um módulo personalizado SafeNetOtpRealm.json e um tema personalizado sas-login-ui. Esta estrutura de arquivo pode ser usada no arquivo de arquivo Docker Compose compartilhado com este repositório ou em outros casos semelhantes:

.
├── certs
│   ├── fullchain.pem
│   └── privkey.pem
├── keycloak.yml
└── safenet
    ├── SafeNetOtpRealm.json
    └── sas-login-ui

O Lets Encrypt não deve ser renomeado ou convertido para .crt!

Aqui está um exemplo de arquivo do Docker Compose

version: '3.7'

services:
  keycloak:
    container_name: keycloak
    image: quay.io/keycloak/keycloak:20.0.5 ou latest
    restart: always
    ports:
      - 8080:8080
      - 8443:8443
    environment:
      - KEYCLOAK_ADMIN=admin
      - KEYCLOAK_ADMIN_PASSWORD=admin
      - KEYCLOAK_IMPORT=/tmp/SafeNetOtpRealm.json
      - KEYCLOAK_DEFAULT_THEME=sas-login-ui
      - KC_DB=<banco-de-dados>
      - KC_DB_URL=jdbc:postgresql://<host-do-banco>:<porta>/keycloak
      - KC_DB_USERNAME=<sername-do-banco>
      - KC_DB_PASSWORD=<password-do-banco>
      - KC_HOSTNAME=<host-do-servidor>
      - KC_HTTP_PORT=<porta-http>
      - KC_HTTPS_PORT=<porta-https>
      - KC_HTTPS_CERTIFICATE_FILE=/etc/x509/https/tls.crt
      - KC_HTTPS_CERTIFICATE_KEY_FILE=/etc/x509/https/tls.key
      - JAVA_OPTS_APPEND="-D keycloak.profile.feature.upload_script=enabled"
    volumes:
      - ./safenet/SafeNetOtpRealm.json:/tmp/SafeNetOtpRealm.json
      - ./safenet/sas-login-ui/:/opt/jboss/keycloak/themes/sas-login-ui/
      - ./certs/fullchain.pem:/etc/x509/https/tls.crt
      - ./certs/privkey.pem:/etc/x509/https/tls.key
    command: start-dev

Implantando e testando o servidor Keycloak

Assumindo que os arquivos estejam nos diretórios corretos e as permissões estejam configuradas corretamente, agora você está pronto para executar e testar o serviço!

1- Execute o Docker com Keycloak:

sudo docker-compose -f keycloak.yml up

2- Para verificar se tudo está funcionando, abra um navegador e navegue até o host keycloak usando,

https:// por exemplo https://keycloak.tech.tk

A página principal do Keycloak é exibida sem erros de certificado ✔

Clicar no login do Keycloak do console de administração é exibido com o tema definido (opcional) ✔

A navegação para o host do Keycloak por HTTPS deve funcionar sem erros ou avisos

Selecionar para fazer login deve exibir o tema (se usado)

Painel informando a versão utilizada

Em resumo, a configuração do Keycloak com SSL e integração ao banco de dados PostgreSQL pode ser um processo desafiador, mas seguindo os passos descritos neste artigo, é possível realizar com sucesso. Certificar-se de que todos os arquivos estão nos diretórios corretos e que as permissões adequadas foram definidas é fundamental. Além disso, é importante lembrar que, ao configurar um serviço de autenticação, como o Keycloak, é essencial garantir que ele seja seguro e protegido. Com isso em mente, este artigo ofereceu um guia abrangente e útil para quem deseja configurar o Keycloak com SSL e integração ao banco de dados PostgreSQL. Esperamos que este guia tenha sido útil e que você tenha sucesso em sua configuração!

Apêndice

Nesta seção, examino ferramentas e comandos úteis ao levantar e gerenciar o Keycloak no Docker.

Verificando o log em busca de erros
Se as coisas não estiverem funcionando, verifique o log:

sudo docker logs keycloak -f

Start, Stop e Remove do container
A seguir estão alguns comandos úteis para gerenciar o contêiner keycloak depois de implantado com o Docker.

Start

sudo docker start keycloak

Stop

sudo docker stop keycloak

Remove

sudo docker rm keycloak