Laboratório: Autenticação Centralizada com Keycloak e SSO em Aplicação Web

Duração estimada

120 min

Passos

11

Validações

5

Versões da documentação consultada

Keycloak 22.0.5 · OpenLDAP 2.5.x · Python Flask (aplicação de exemplo) a versão estável atual · Docker a versão estável atual

Topologia

Uma VM Linux (192.168.56.10) roda Keycloak e OpenLDAP. Uma aplicação web de exemplo (192.168.56.20) conecta-se ao Keycloak para autenticação via OpenID Connect. Usuários são provisionados no LDAP e autenticam-se pela interface do Keycloak.

             +-------------------+
             |   Usuário Final   |
             +--------+----------+
                      |
                      v
+---------------------+---------------------+
|         VM 1 (192.168.56.10)             |
|   +-----------+     +----------------+   |
|   | OpenLDAP  |<--->|    Keycloak    |   |
|   +-----------+     +----------------+   |
+---------------------+---------------------+
                      |
                      v
             +--------+----------+
             | Aplicação Web     |
             | (192.168.56.20)  |
             +------------------+

Equipamentos e software

Roteiro

1. Preparar a VM e instalar dependências

   Atualize o sistema e instale Docker. Docker facilita o isolamento e a gestão dos serviços.

   sudo apt update && sudo apt upgrade -y
   sudo apt install docker.io docker-compose -yCopiar

   O que você deve ver: Docker instalado, comandos 'docker' e 'docker-compose' disponíveis.

2. Subir o OpenLDAP com Docker

   O Keycloak precisa de um diretório externo para autenticação corporativa. O OpenLDAP será esse backend.

   mkdir ~/ldap-lab && cd ~/ldap-lab
   echo 'version: "3"
   services:
     openldap:
       image: osixia/openldap:1.5.0
       container_name: openldap
       environment:
         - LDAP_ORGANISATION=UpnetixLab
         - LDAP_DOMAIN=lab.upnetix
         - LDAP_ADMIN_PASSWORD=admin
       ports:
         - "389:389"
       volumes:
         - ./ldap-data:/var/lib/ldap
         - ./ldap-config:/etc/ldap/slapd.d'
   > docker-compose.yml
   docker-compose up -dCopiar

   O que você deve ver: Container 'openldap' em execução na porta 389.

3. Popular o OpenLDAP com usuários de teste

   Usuários precisam existir no LDAP para autenticação federada. Crie um LDIF básico.

   echo 'dn: ou=users,dc=lab,dc=upnetix
   objectClass: organizationalUnit
   ou: users
   
   dn: uid=jose,ou=users,dc=lab,dc=upnetix
   objectClass: inetOrgPerson
   sn: Jose
   cn: Jose da Silva
   uid: jose
   userPassword: jose123
   
   dn: uid=ana,ou=users,dc=lab,dc=upnetix
   objectClass: inetOrgPerson
   sn: Ana
   cn: Ana Souza
   uid: ana
   userPassword: ana123' > users.ldif
   docker cp users.ldif openldap:/tmp/users.ldif
   docker exec openldap ldapadd -x -D "cn=admin,dc=lab,dc=upnetix" -w admin -f /tmp/users.ldifCopiar

   O que você deve ver: Usuários 'jose' e 'ana' criados no OpenLDAP.

4. Subir o Keycloak com Docker

   Keycloak será o provedor de identidade central. Use Docker para facilitar o setup.

   docker run -d --name keycloak --net=host -e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=admin quay.io/keycloak/keycloak:22.0.5 start-devCopiar

   O que você deve ver: Keycloak rodando em http://localhost:8080

5. Acessar o painel de administração do Keycloak

   Acesse o painel para configurar integrações. Use as credenciais admin/admin.

   N/ACopiar

   O que você deve ver: Painel disponível em http://localhost:8080/admin

6. Configurar o Keycloak para autenticação LDAP

   Keycloak precisa buscar usuários no LDAP. Configure um User Federation apontando para o OpenLDAP.

   No painel: 'User Federation' > 'ldap' > Adicionar novo provedor LDAP. Parâmetros:
   - Vendor: Other
   - Connection URL: ldap://localhost:389
   - Bind DN: cn=admin,dc=lab,dc=upnetix
   - Bind Credential: admin
   - Users DN: ou=users,dc=lab,dc=upnetix
   - Edit Mode: READ_ONLYCopiar

   O que você deve ver: Usuários do LDAP aparecem em 'Users' no Keycloak.

7. Criar um novo Realm para o laboratório

   Realms isolam configurações e usuários. Crie um para separar o ambiente.

   No painel: 'Add realm' > Nome: lab-realmCopiar

   O que você deve ver: Novo realm 'lab-realm' criado.

8. Configurar um Client OIDC para a aplicação web

   A aplicação web precisa autenticar via Keycloak. Crie um Client OIDC.

   No painel: 'Clients' > 'Create client'
   - Client ID: flask-app
   - Client Type: OpenID Connect
   - Root URL: http://192.168.56.20:5000/
   - Valid Redirect URIs: http://192.168.56.20:5000/*Copiar

   O que você deve ver: Client 'flask-app' criado e listado.

9. Subir aplicação Flask de exemplo integrada ao Keycloak

   A aplicação vai testar o login centralizado. Use um exemplo com Flask e Authlib.

   ssh 192.168.56.20
   sudo apt update && sudo apt install python3-pip -y
   pip3 install Flask Authlib
   cat > app.py <<EOF
   from flask import Flask, redirect, url_for, session
   from authlib.integrations.flask_client import OAuth
   app = Flask(__name__)
   app.secret_key = 'supersecret'
   oauth = OAuth(app)
   conf = {
     'client_id': 'flask-app',
     'client_secret': 'CONSULTE A DOCUMENTAÇÃO',
     'api_base_url': 'http://192.168.56.10:8080/realms/lab-realm/protocol/openid-connect',
     'access_token_url': 'http://192.168.56.10:8080/realms/lab-realm/protocol/openid-connect/token',
     'authorize_url': 'http://192.168.56.10:8080/realms/lab-realm/protocol/openid-connect/auth',
     'client_kwargs': {'scope': 'openid profile email'}
   }
   oauth.register('keycloak', **conf)
   @app.route('/')
   def homepage():
       user = dict(session).get('user', None)
       if user:
           return f'Olá, {user["preferred_username"]}! <a href="/logout">Logout</a>'
       return '<a href="/login">Login</a>'
   @app.route('/login')
   def login():
       redirect_uri = url_for('auth', _external=True)
       return oauth.keycloak.authorize_redirect(redirect_uri)
   @app.route('/auth')
   def auth():
       token = oauth.keycloak.authorize_access_token()
       user = oauth.keycloak.parse_id_token(token)
       session['user'] = user
       return redirect('/')
   @app.route('/logout')
   def logout():
       session.pop('user', None)
       return redirect('/')
   if __name__ == '__main__':
       app.run(host='0.0.0.0', port=5000)
   EOF
   python3 app.pyCopiar

   O que você deve ver: Aplicação Flask rodando em http://192.168.56.20:5000/

10. Testar o login centralizado na aplicação

    Acesse a aplicação web, clique em Login e faça autenticação via Keycloak usando usuário do LDAP.

    N/ACopiar

    O que você deve ver: Redirecionamento para Keycloak, login com 'jose' ou 'ana', retorno autenticado para a aplicação.

11. Testar SSO entre múltiplas abas

    Abra duas abas da aplicação. Faça login em uma, recarregue a outra. O SSO deve manter a sessão.

    N/ACopiar

    O que você deve ver: Usuário autenticado em ambas as abas sem novo login.

Como saber que funcionou

Troubleshooting

Segurança e hardening

• Altere as senhas padrão antes de uso em produção
• Restrinja o acesso à porta 389 (LDAP) e 8080 (Keycloak) apenas à rede interna
• Configure TLS para Keycloak e OpenLDAP em ambientes reais
• Utilize Edit Mode 'READ_ONLY' para evitar alterações acidentais no LDAP pelo Keycloak
• Revise as permissões dos arquivos de configuração

Checklist final

• OpenLDAP rodando e populado com usuários
• Keycloak acessível via painel de administração
• Usuários do LDAP visíveis no Keycloak
• Client OIDC criado para a aplicação
• Aplicação Flask rodando e autenticando via Keycloak
• SSO funcionando entre abas