Swift Academy · Aula

Middleware e Autenticação

Adicione lógica transversal e proteja rotas.

Middleware e Autenticação é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O que é Middleware?

Middleware fica entre a requisição recebida e o manipulador da rota, podendo inspecionar ou modificar tanto a requisição quanto a resposta. Ele é ideal para registros, CORS, tratamento de erros e autenticação.

import Vapor

O protocolo Middleware

Um middleware personalizado está em conformidade com AsyncMiddleware e implementa respond(to:chainingTo:). Execute o processamento necessário e depois chame next.respond(to:) para continuar a cadeia.

struct LogMiddleware: AsyncMiddleware {
    func respond(to req: Request, chainingTo next: AsyncResponder) async throws -> Response {
        req.logger.info("Incoming: " + req.url.path)
        return try await next.respond(to: req)
    }
}

Registrando Middleware globalmente

Adicione o middleware a app.middleware para executá-lo em todas as requisições. A ordem é importante — os middlewares são executados na ordem em que foram adicionados.

app.middleware.use(LogMiddleware())

Middleware integrado

O Vapor inclui middlewares úteis: ErrorMiddleware converte erros lançados em respostas, FileMiddleware fornece arquivos estáticos e CORSMiddleware trata requisições de origens diferentes.

let cors = CORSMiddleware(configuration: .default())
app.middleware.use(cors)

Middleware específico de rota

Aplique middleware somente a algumas rotas agrupando-as com ele. As rotas dentro do grupo ficam protegidas; as demais, não.

let protected = app.grouped(LogMiddleware())
protected.get("dashboard") { req in "Secret dashboard" }

Conceitos de autenticação

O sistema de autenticação do Vapor tem duas partes: um modelo Authenticatable (seu usuário) e um middleware Authenticator que verifica as credenciais e armazena o usuário na requisição.

final class AppUser: Model, Content, Authenticatable {
    static let schema = "users"
    @ID(key: .id) var id: UUID?
    @Field(key: "username") var username: String
    @Field(key: "password_hash") var passwordHash: String
    init() {}
}

Escrevendo um autenticador básico

Um AsyncBasicAuthenticator trata a autenticação HTTP Basic. Implemente authenticate(basic:for:): busque o usuário, verifique a senha e chame req.auth.login(user) em caso de sucesso.

struct UserAuthenticator: AsyncBasicAuthenticator {
    func authenticate(basic: BasicAuthorization, for req: Request) async throws {
        guard let user = try await AppUser.query(on: req.db)
            .filter(\.$username == basic.username).first() else { return }
        if try Bcrypt.verify(basic.password, created: user.passwordHash) {
            req.auth.login(user)
        }
    }
}

Aplicando hash às senhas com Bcrypt

Nunca armazene senhas em texto simples. O Vapor inclui Bcrypt para aplicar hash no cadastro e verificar no login. O hash é unidirecional; a verificação compara uma senha candidata com o hash armazenado.

let hash = try Bcrypt.hash("s3cret")
let ok = try Bcrypt.verify("s3cret", created: hash) // true

Protegendo rotas com um guard

Combine o autenticador com AppUser.guardMiddleware(), que rejeita requisições não autenticadas com o status 401. Agrupe as rotas protegidas atrás de ambos.

let protected = app.grouped(
    UserAuthenticator(),
    AppUser.guardMiddleware()
)
protected.get("me") { req -> String in
    let user = try req.auth.require(AppUser.self)
    return user.username
}

Lendo o usuário autenticado

Dentro de um manipulador protegido, recupere o usuário conectado com req.auth.require(_:) (lança uma exceção se estiver ausente) ou req.auth.get(_:) (opcional). É assim que você restringe os dados ao usuário atual.

app.get("profile") { req -> String in
    let user = try req.auth.require(AppUser.self)
    return "Hello, " + user.username
}

Autenticação por token

Para APIs, tokens de portador são comuns. Um modelo de token está em conformidade com ModelTokenAuthenticatable, permitindo que o Vapor verifique um cabeçalho Authorization: Bearer ... e carregue automaticamente o usuário associado.

let tokenProtected = app.grouped(
    UserToken.authenticator(),
    AppUser.guardMiddleware()
)

Verificação rápida: camada intermediária e autenticação

Confirme seu entendimento.

Recapitulação: camada intermediária e autenticação

Você aprendeu a interceptar solicitações e protegê-las:

A camada intermediária (AsyncMiddleware) envolve as solicitações; registre-a globalmente ou por grupo de rotas.
Use componentes integrados como ErrorMiddleware e CORSMiddleware.
Transforme um usuário em Authenticatable, escreva um Authenticator e chame req.auth.login.
Aplique hash com Bcrypt, proteja rotas com guardMiddleware() e leia o usuário por meio de req.auth.require.

Perguntas Frequentes

A aula “Middleware e Autenticação” é grátis?

Sim — o texto completo de “Middleware e Autenticação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Middleware e Autenticação”?

Adicione lógica transversal e proteja rotas. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Middleware e Autenticação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy