Introdução

Com o crescente número de aplicações web e móveis, a gestão eficaz de acesso e autenticação se tornou uma necessidade fundamental para proteger dados sensíveis e garantir a privacidade dos usuários. Neste tutorial, vamos explorar como desenvolver um sistema de gerenciamento de acesso utilizando OAuth 2.0 em combinação com JWT (JSON Web Tokens) e o Keycloak, uma poderosa ferramenta de gerenciamento de identidade e acesso. O objetivo é fornecer uma implementação passo-a-passo que possibilite a construção de um sistema seguro e escalável, permitindo o uso de anéis de autenticação para controle de acesso em diferentes níveis da aplicação. Aprenderemos a configurar o ambiente, criar as configurações necessárias e implementar a lógica para autenticar usuários e proteger recursos. Vamos começar!

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o JDK (Java Development Kit) e o Maven instalados em sua máquina. Verifique as versões instaladas usando os comandos `java -version` e `mvn -version`. Caso não os tenha instalados, siga as instruções oficiais nos sites das respectivas ferramentas.

    commands
    # Verificar versões instaladas
    java -version
    mvn -version

  2. Criação do Projeto Spring Boot

    Utilize o Spring Initializr para gerar um novo projeto Spring Boot com as dependências necessárias. Configure o projeto com as opções: **Project**: Maven, **Language**: Java, **Spring Boot**: última versão estável, **Packaging**: Jar, **Java**: 11 ou superior. Adicione as dependências ‘Spring Web’, ‘Spring Security’, ‘Spring Data JPA’, ‘JWT’ e ‘Keycloak Spring Boot Starter’. Baixe e descompacte o projeto em seu ambiente de trabalho.

    pom.xml
    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>access-control-system</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>access-control-system</name>
  <description>Sistema de gerenciamento de acesso com OAuth 2.0</description>
  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>io.jsonwebtoken</groupId>
      <artifactId>jjwt</artifactId>
      <version>0.9.1</version>
    </dependency>
    <dependency>
      <groupId>org.keycloak</groupId>
      <artifactId>keycloak-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

  3. Configuração do Keycloak

    Baixe e instale o Keycloak em sua máquina. Após a instalação, inicialize o servidor e crie um novo realm para o seu projeto. Dentro do realm, configure um cliente e anote as credenciais que você irá utilizar no seu projeto Spring Boot. Não se esqueça de habilitar o fluxo de ‘Authorization Code’.

    commands
    # Baixar e iniciar o Keycloak
    docker run -p 8080:8080 -e KEYCLOAK_USER=admin -e KEYCLOAK_PASSWORD=admin jboss/keycloak
    # Acesse o Keycloak no navegador
    http://localhost:8080/auth

  4. Configuração do Keycloak no Spring Boot

    No seu projeto, crie um arquivo `application.properties` e configure as propriedades do Keycloak, incluindo o realm, o cliente e a URL do servidor Keycloak.

    application.properties
    keycloak.realm=SeuRealm
keycloak.auth-server-url=http://localhost:8080/auth
keycloak.resource=seu-cliente
keycloak.public-client=true
keycloak.security-constraints[0].authRoles[0]=user
keycloak.security-constraints[0].securityCollections[0].patterns[0]=/*

  5. Implementação do Filtro de Segurança

    Implemente um filtro de segurança que usará o JWT para autenticar requests e controlar o acesso a rotas da sua aplicação. Crie uma classe `SecurityConfig` para configurar o Spring Security.

    SecurityConfig.java
    package com.example.accesscontrolsystem.config;

import org.keycloak.adapters.springsecurity.KeycloakConfiguration;
import org.keycloak.adapters.springsecurity.config.KeycloakWebSecurityConfigurerAdapter;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

@KeycloakConfiguration
@EnableWebSecurity
public class SecurityConfig extends KeycloakWebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
        http
            .authorizeRequests()
            .antMatchers("/public/**").permitAll()
            .anyRequest().authenticated();
    }

    @Bean
    public AuthenticationSuccessHandler mySuccessHandler() {
        return new MyAuthenticationSuccessHandler();
    }
}

  6. Criação de Controlador e Model

    Implemente um modelo simples, como `User`, e um controlador que terá endpoints protegidos. Os usuários poderão gerar tokens JWT para acessar recursos restritos. O controlador utilizará a injeção de dependência para contatar o serviço de autenticação.

    User.java
    package com.example.accesscontrolsystem.model;

public class User {
    private String username;
    private String password;

    // Getters e Setters
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

    UserController.java
    package com.example.accesscontrolsystem.controller;

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @GetMapping("/me")
    public String getCurrentUser() {
        return "Hello, you are authenticated!";
    }
}

  7. Implementação de Testes Unitários

    Crie testes unitários para validar a funcionalidade do controlador e da autenticação. Você pode usar Mockito para simular o comportamento de componentes como o repositório de usuários ou serviços externos.

    UserControllerTest.java
    package com.example.accesscontrolsystem.controller;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;

@WebMvcTest(UserController.class)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @BeforeEach
    public void setUp() throws Exception {
    }

    @Test
    public void testGetCurrentUser() throws Exception {
        mockMvc.perform(get("/api/users/me"))
                .andExpect(status().isOk());
    }
}

  8. Executando a Aplicação e Testes

    Use o Maven para compilar e executar a aplicação. Em seguida, utilize ferramentas como Postman para testar os endpoints da API, autenticando-se com um usuário válido para acessar os recursos protegidos.

    commands
    # Compilar e executar a aplicação
    mvn spring-boot:run
    # Executar os testes unitários
    mvn test

    curl_examples
    # Testar o endpoint protegido
    curl -X GET http://localhost:8080/api/users/me -H "Authorization: Bearer {token_jwt}"

Conclusão

Neste tutorial, você aprendeu como implementar um sistema de gerenciamento de acesso usando OAuth 2.0, JWT e Keycloak. Através da criação de um projeto Spring Boot, configuramos a segurança para proteger nossas rotas e garantir que apenas usuários autenticados pudéssemos acessar informações restritas. Este conhecimento é fundamental para desenvolver aplicações seguras que respeitem a privacidade dos dados dos usuários. Com a base que você adquiriu aqui, está pronto para explorar recursos de segurança mais avançados e se aprofundar em práticas recomendadas para o gerenciamento de identidade em aplicações modernas.

Hashtags

#Java #SpringBoot #OAuth2 #Keycloak #JWT #Segurança