Keycloak – Identity Management dla Enterprise

Dlaczego Keycloak to game-changer w enterprise?

Zarządzanie użytkownikami w aplikacjach enterprise to prawdziwy koszmar. Każda aplikacja ma własny system logowania, użytkownicy pamiętają dziesiątki haseł, a administratorzy tracą głowę nad integracją różnych systemów. Keycloak rozwiązuje te problemy jednym uderzeniem – centralnym systemem zarządzania tożsamością.

W 2018 roku coraz więcej firm przechodzi na architekturę mikrousług, gdzie tradycyjne podejście do autoryzacji przestaje działać. Keycloak dostarcza nowoczesne standardy jak OAuth2 i OpenID Connect, które stają się podstawą bezpiecznych aplikacji.

Czym jest Keycloak i dlaczego warto go używać?

Keycloak to open source Identity and Access Management (IAM) rozwiązanie stworzone przez Red Hat. W przeciwieństwie do komercyjnych rozwiązań jak Active Directory Federation Services czy Auth0, Keycloak możesz uruchomić we własnej infrastrukturze bez licencyjnych ograniczeń.

Główne zalety Keycloak:
– **Single Sign-On (SSO)** – jeden login do wszystkich aplikacji
– **Standardy branżowe** – OAuth2, OpenID Connect, SAML 2.0
– **Social Login** – integracja z Google, Facebook, Twitter
– **Federacja tożsamości** – łączenie z LDAP, Active Directory
– **Multi-tenancy** – obsługa wielu organizacji w jednej instancji
– **Admin Console** – webowy interfejs zarządzania

Instalacja i pierwsze uruchomienie

Najszybszy sposób na start z Keycloak to pobranie standalone wersji:

# Pobierz Keycloak 4.5.0 (najnowsza wersja w październiku 2018)
wget https://downloads.jboss.org/keycloak/4.5.0.Final/keycloak-4.5.0.Final.tar.gz

# Rozpakuj
tar -xzf keycloak-4.5.0.Final.tar.gz
cd keycloak-4.5.0.Final

# Uruchom w trybie standalone
./bin/standalone.sh

Po uruchomieniu Keycloak będzie dostępny pod adresem `http://localhost:8080`. Przy pierwszym uruchomieniu musisz utworzyć konto administratora.

Podstawowe koncepty – Realms, Clients i Users

Keycloak organizuje dane w hierarchiczną strukturę:

### Tworzenie nowego Realm

{
  "realm": "company-portal",
  "displayName": "Company Portal",
  "enabled": true,
  "sslRequired": "external",
  "registrationAllowed": false,
  "loginWithEmailAllowed": true,
  "duplicateEmailsAllowed": false,
  "resetPasswordAllowed": true,
  "editUsernameAllowed": false,
  "bruteForceProtected": true
}

Ta konfiguracja tworzy realm `company-portal` z podstawowymi ustawieniami bezpieczeństwa. W Admin Console możesz importować ten JSON lub skonfigurować wszystko przez interfejs graficzny.

Konfiguracja pierwszego Client – Spring Boot App

Załóżmy że mamy aplikację Spring Boot która ma być zabezpieczona przez Keycloak. Tworzymy nowego Client:

Konfiguracja Client w Keycloak:

{
  "clientId": "spring-boot-app",
  "enabled": true,
  "clientAuthenticatorType": "client-secret",
  "redirectUris": [
    "http://localhost:8081/*"
  ],
  "webOrigins": [
    "http://localhost:8081"
  ],
  "protocol": "openid-connect",
  "publicClient": false,
  "frontchannelLogout": true,
  "fullScopeAllowed": true
}

Integracja z aplikacją Spring Boot

Dodaj Keycloak adapter do swojej aplikacji Spring Boot:

    org.keycloak
    keycloak-spring-boot-starter
    4.5.0.Final


    org.keycloak
    keycloak-spring-security-adapter
    4.5.0.Final

Konfiguracja w `application.yml`:

keycloak:
  auth-server-url: http://localhost:8080/auth
  realm: company-portal
  resource: spring-boot-app
  credentials:
    secret: your-client-secret-from-keycloak
  use-resource-role-mappings: true
  
server:
  port: 8081

Security Configuration:

@Configuration
@EnableWebSecurity
@ComponentScan(basePackageClasses = KeycloakSecurityComponents.class)
public class SecurityConfig extends KeycloakWebSecurityConfigurerAdapter {

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) {
        auth.authenticationProvider(keycloakAuthenticationProvider());
    }

    @Bean
    @Override
    protected SessionAuthenticationStrategy sessionAuthenticationStrategy() {
        return new RegisterSessionAuthenticationStrategy(
            new SessionRegistryImpl());
    }

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

Zarządzanie użytkownikami i rolami

Keycloak oferuje elastyczny system ról i grup:

### Tworzenie ról
1. **Realm Roles** – role globalne w ramach realm
2. **Client Roles** – role specyficzne dla konkretnej aplikacji
3. **Composite Roles** – role składające się z innych ról

@RestController
public class UserController {
    
    @GetMapping("/profile")
    @PreAuthorize("hasRole('USER')")
    public ResponseEntity getUserProfile(Principal principal) {
        KeycloakPrincipal keycloakPrincipal = (KeycloakPrincipal) principal;
        KeycloakSecurityContext context = keycloakPrincipal.getKeycloakSecurityContext();
        
        AccessToken token = context.getToken();
        
        UserProfile profile = UserProfile.builder()
            .username(token.getPreferredUsername())
            .email(token.getEmail())
            .firstName(token.getGivenName())
            .lastName(token.getFamilyName())
            .roles(token.getRealmAccess().getRoles())
            .build();
            
        return ResponseEntity.ok(profile);
    }
    
    @GetMapping("/admin/users")
    @PreAuthorize("hasRole('ADMIN')")
    public ResponseEntity> getUsers() {
        // Admin endpoint
        return ResponseEntity.ok(Arrays.asList("user1", "user2"));
    }
}

Single Sign-On (SSO) między aplikacjami

Prawdziwa siła Keycloak ujawnia się gdy integrujesz wiele aplikacji. SSO pozwala użytkownikowi zalogować się raz i mieć dostęp do wszystkich aplikacji.

### Konfiguracja drugiej aplikacji (Angular)

Dla frontend aplikacji Angular używamy `keycloak-angular` adaptera:

npm install keycloak-angular@5.1.0 keycloak-js@4.5.0

// app.module.ts
import { KeycloakAngularModule, KeycloakService } from 'keycloak-angular';

function initializeKeycloak(keycloak: KeycloakService) {
  return () =>
    keycloak.init({
      config: {
        url: 'http://localhost:8080/auth',
        realm: 'company-portal',
        clientId: 'angular-app',
      },
      initOptions: {
        onLoad: 'login-required',
        checkLoginIframe: false,
      },
    });
}

@NgModule({
  imports: [KeycloakAngularModule],
  providers: [
    {
      provide: APP_INITIALIZER,
      useFactory: initializeKeycloak,
      multi: true,
      deps: [KeycloakService],
    },
  ],
})
export class AppModule {}

OAuth2 i OpenID Connect w praktyce

Keycloak implementuje pełne wsparcie dla OAuth2 i OpenID Connect. Oto jak wygląda typowy flow autoryzacji:

### Testowanie tokenów JWT

Keycloak generuje JWT tokeny które możesz zweryfikować:

@Component
public class JwtTokenValidator {
    
    @Value("${keycloak.auth-server-url}")
    private String authServerUrl;
    
    @Value("${keycloak.realm}")
    private String realm;
    
    public boolean validateToken(String token) {
        try {
            // Pobierz public key z Keycloak
            String jwksUrl = authServerUrl + "/realms/" + realm + "/protocol/openid_connect/certs";
            
            // Walidacja tokenu
            Algorithm algorithm = Algorithm.RSA256(getRSAPublicKey(jwksUrl), null);
            JWTVerifier verifier = JWT.require(algorithm)
                .withIssuer(authServerUrl + "/realms/" + realm)
                .build();
                
            DecodedJWT jwt = verifier.verify(token);
            return true;
        } catch (JWTVerificationException e) {
            return false;
        }
    }
}

Federacja tożsamości – integracja z LDAP

W większości firm użytkownicy już istnieją w Active Directory lub LDAP. Keycloak pozwala na federację – synchronizację użytkowników bez migracji.

Konfiguracja LDAP User Federation:

Monitoring i troubleshooting

Keycloak oferuje szczegółowe logowanie zdarzeń:

# Włączenie debug logs dla authentication
echo 'LOGGER.org.keycloak.authentication.level=DEBUG' >> standalone/configuration/logging.properties

# Monitoring failed logins
tail -f standalone/log/server.log | grep "WARN.*authentication"

Najczęstsze problemy:
– **Invalid redirect URI** – sprawdź konfigurację Client redirectUris
– **CORS errors** – dodaj proper webOrigins w Client settings
– **Token expired** – sprawdź token lifecycle settings w Realm
– **Role mapping issues** – zweryfikuj Client Scope i Role Mappings

Przydatne zasoby:

• Oficjalna dokumentacja Keycloak
• Keycloak na GitHub
• Server Administration Guide
• OAuth2 Specification
• OpenID Connect Specification