Secure authentication powered by Micronaut

A robust JWT-based authentication service built with Micronaut Java Framework. Provides secure login, registration, token management, and role-based authorization for modern applications.

Get started

View docs

Features

Enterprise-grade JWT Authentication

Built with the powerful Micronaut Framework for exceptional performance and minimal memory footprint.

Advanced JWT Authentication: Secure JSON Web Token implementation with customizable claims, expiration, and refresh token support built using Micronaut's security module.
Role-Based Access Control: Fine-grained access control with user roles and permissions. Seamlessly protect your endpoints with Micronaut's declarative security annotations.
High Performance: Leverages Micronaut's compile-time DI and AOP for blazing fast startup times and minimal memory footprint. Perfect for microservices and cloud deployments.
API Integration: Simple RESTful API endpoints that can be easily integrated with any front-end framework, mobile app, or third-party service.
Highly Configurable: Customize token expiration, signature algorithms, claim attributes and auth flows to match your application's specific security requirements.

Documentation

How It Works

Simple integration with intuitive API endpoints powered by Micronaut's reactive HTTP client and server.

User Registration/Login:
Users submit credentials through a secure form or API endpoint.
Credential Validation:
Server validates credentials against encrypted database records.
JWT Generation:
Upon successful authentication, server generates a signed JWT containing user claims and permissions.
Token Response:
Access token and refresh token are returned to the client.
Authenticated Requests:
Client includes JWT in Authorization header for subsequent API calls.
Token Verification:
Server validates signature and claims before allowing access to protected resources.

Client

Auth Service

← JWT Token Response →

API Request with JWT Header

Authorized Access

AuthenticationController.java

Swipe to view →

package com.auth.controllers;

import io.micronaut.http.HttpResponse;
import io.micronaut.http.annotation.*;
import io.micronaut.security.annotation.Secured;
import io.micronaut.security.rules.SecurityRule;
import io.micronaut.security.token.jwt.generator.JwtTokenGenerator;
import javax.inject.Inject;
import java.util.HashMap;
import java.util.Map;

@Controller("/api/auth")
public class AuthenticationController {

    @Inject
    private JwtTokenGenerator jwtTokenGenerator;

    @Inject
    private AuthenticationService authService;

    @Post("/login")
    @Secured(SecurityRule.IS_ANONYMOUS)
    public HttpResponse<?> login(@Body LoginRequest request) {
        if (authService.authenticate(request.getUsername(), request.getPassword())) {
            Map<String, Object> claims = new HashMap<>();
            claims.put("username", request.getUsername());
            claims.put("roles", authService.getRolesForUser(request.getUsername()));

            String token = jwtTokenGenerator
                    .generateToken(claims)
                    .orElseThrow(() -> new RuntimeException("Could not generate token"));

            return HttpResponse.ok(new TokenResponse(token));
        }
        return HttpResponse.unauthorized();
    }

    @Get("/profile")
    @Secured(SecurityRule.IS_AUTHENTICATED)
    public UserProfile getUserProfile(Authentication authentication) {
        String username = authentication.getName();
        return authService.getUserProfile(username);
    }
}

Scroll horizontally to see complete code