b. JWT

O primeiro passo para construir a camada de segurança é entender os JSON Web Tokens (JWT) e criar o módulo de interface auth, que define o contrato da API de autenticação.

1. JSON Web Token

O JWT é uma forma compacta e segura para URLs de representar claims (afirmações) entre duas partes. É o padrão usado pela plataforma para transportar a identidade do usuário autenticado entre os serviços sem armazenar estado de sessão no servidor — o que o torna naturalmente compatível com a escalabilidade horizontal.

Um JWT é composto de três partes codificadas em Base64Url, separadas por pontos.

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9.eyJpc3MiOiJJbnNwZXIiLCJpYXQiOjE3MDMwMDgzMzgsImV4cCI6MjAxODU0MTEz
OCwiYXVkIjoid3d3Lmluc3Blci5lZHUuYnIiLCJzdWIiOiJodW1iZXJ0b3JzQGluc3Blci5lZHUuYnIiLCJHaXZlbk5hbWUiOiJId
W1iZXJ0byIsIlN1cm5hbWUiOiJTYW5kbWFubiIsIkVtYWlsIjoiaHVtYmVydG9yc0BpbnNwZXIuZWR1LmJyIiwiUm9sZSI6IlByb2
Zlc3NvciJ9.SsGdvR5GbYWTRbxY7IGxHt1vSxhkpRueBJWsi0lrPhJVCICp119QjU8F3QvHW0yF5tw-HhQ9RVh0l89t4M0LNw

{
    "alg": "HS256"
}

{
    "iss": "Insper",
    "iat": 1703008338,
    "exp": 2018541138,
    "aud": "www.insper.edu.br",
    "sub": "humbertors@insper.edu.br",
    "GivenName": "Humberto",
    "Surname": "Sandmann",
    "Email": "humbertors@insper.edu.br",
    "Role": "Professor"
    }

HMACSHA512(
    base64UrlEncode(header) + "." +
    base64UrlEncode(payload),
    qwertyuiopasdfghjklzxcvbnm123456,
)

As principais claims usadas nesta plataforma são:

Depois de um login bem-sucedido, o servidor gera um JWT, coloca-o em um cookie HttpOnly e o devolve ao navegador. Em cada requisição seguinte, o navegador envia o cookie automaticamente — o Gateway o lê e resolve a identidade sem pedir que o usuário faça login de novo.

sequenceDiagram
  autonumber
  actor User
  User->>+Auth Service: login (email + senha)
  Auth Service->>Auth Service: valida as credenciais e gera o JWT
  Auth Service->>-User: Set-Cookie: __store_jwt_token=<jwt>
  User->>User: o navegador armazena o cookie
  User->>Gateway: as requisições seguintes levam o cookie automaticamente

2. O módulo de interface auth

O módulo auth segue o mesmo padrão do módulo account: é uma biblioteca (e não uma aplicação executável) que define o contrato da API e os DTOs compartilhados entre o auth-service e qualquer outro microsserviço que precise chamar os endpoints de autenticação via Feign.

2.1 Repositório

Crie um novo repositório git para a interface auth e adicione-o como submódulo:

git submodule add <repository_url> api/auth

📁 api/
├── 📁 account/
├── 📁 account-service/
└── 📁 auth/

2.2 Código

Use o Spring Initializr para gerar um projeto Maven com as seguintes configurações:

• Group: store
• Artifact: auth
• Package name: store.auth
• Packaging: Jar
• Java: 25

Dependências a adicionar:

• Lombok — reduz o código repetitivo (boilerplate) com processamento de anotações em tempo de compilação
• OpenFeign — cliente HTTP declarativo para chamadas entre serviços

Apague o AuthApplication.java, o src/test/ e o src/main/resources/ — este módulo é uma biblioteca, não um serviço executável.

A estrutura resultante é:

📁 api/
└── 📁 auth/
    ├── 📁 src/
    │   └── 📁 main/
    │       └── 📁 java/
    │           └── 📁 store/
    │               └── 📁 auth/
    │                   ├──  AuthController.java
    │                   ├──  LoginIn.java
    │                   ├──  RegisterIn.java
    │                   └──  TokenOut.java
    └──  pom.xml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>4.0.3</version>
        <relativePath/>
    </parent>

    <groupId>store</groupId>
    <artifactId>auth</artifactId>
    <version>1.0.0</version>
    <name>auth</name>

    <properties>
        <java.version>25</java.version>
        <spring-cloud.version>2025.1.0</spring-cloud.version>
        <maven.compiler.proc>full</maven.compiler.proc>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>store</groupId>
            <artifactId>account</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

package store.auth;

import java.util.Map;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;

import store.account.AccountOut;

@FeignClient(
    name="auth",
    url="http://auth:8080"
)
public interface AuthController {

    public static String AUTH_COOKIE_TOKEN = "__store_jwt_token";

    @PostMapping("/auth/login")
    public ResponseEntity<Void> login(
        @RequestBody LoginIn in
    );

    @PostMapping("/auth/register")
    public ResponseEntity<Void> register(
        @RequestBody RegisterIn in
    );

    @GetMapping("/auth/whoiam")
    public ResponseEntity<AccountOut> whoIAm(
        @RequestHeader(value = "id-account", required = true) String idAccount
    );

    @GetMapping("/auth/health-check")
    public ResponseEntity<Void> healthCheck();

    @PostMapping("/auth/solve")
    public ResponseEntity<Map<String, String>> solveToken(
        @RequestBody TokenOut map
    );

    @GetMapping("/auth/logout")
    public ResponseEntity<Void> logout();

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package store.auth;

import lombok.Builder;

@Builder
public record LoginIn(

    String email,
    String password

) {
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package store.auth;

import lombok.Builder;

@Builder
public record RegisterIn(

    String name,
    String email,
    String password

) {
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package store.auth;

import lombok.Builder;

@Builder
public record TokenOut(

    String token

) {
}

2.3 Instalação

Instale a interface no repositório Maven local para que o auth-service possa depender dela:

mvn clean install

Pronto! A interface auth está pronta. Na próxima seção, vamos implementar o auth-service, incluindo o JwtService, que assina e valida os tokens, e o AuthService, que orquestra o login e o cadastro.

Rotas abertas