W dzisiejszym dynamicznym środowisku programistycznym, w którym bezpieczeństwo odgrywa kluczową rolę, integracja systemu zarządzania tożsamością z warstwą front-end – częścią rozwiązania, którą widzą użytkownicy i z którą wchodzą w interakcję – staje się integralną częścią projektów IT. Potrzebujesz solidnego systemu IAM o potężnych możliwościach, aby zapewnić bezpieczeństwo i komfort korzystania z aplikacji.
Jednym z rozwiązań, które zyskało uznanie w świecie programowania, jest Keycloak – otwartoźródłowe oprogramowanie do zarządzania tożsamością i dostępem. Nie tylko zapewnia ono gotowy zestaw kompleksowych narzędzi do obsługi Identity and Access Management, ale pozwala również na elastyczną konfigurację zgodnie z indywidualnymi potrzebami projektu.
W tym artykule pokażemy Ci, jak zintegrować Keycloak z warstwą front-end aplikacji opartej na Angular. Przeanalizujemy kroki niezbędne do pomyślnej integracji rozwiązania z Twoim front-endem i omówimy korzyści płynące z tego połączenia (w tym spojrzymy na funkcje dostępne w najnowszych wersjach Keycloaka). Zaoferujemy również wskazówki dotyczące konfiguracji i praktyczne przykłady implementacji, skupiając się na prowadzeniu deweloperów, którzy chcą skutecznie zabezpieczyć swoje aplikacje, zapewniając jednocześnie użytkownikom płynne i przyjazne doświadczenie.
Keycloak to potężne rozwiązanie open-source, które zapewnia funkcje związane z uwierzytelnianiem, autoryzacją, tożsamością federacyjną, zarządzaniem sesjami i wieloma innymi zaawansowanymi koncepcjami, co czyni go idealnym wyborem dla projektów wymagających bezpiecznego i zintegrowanego środowiska. Dlatego w Pretius polecamy Keycloak wielu naszym klientom. I nie, nie dostajemy pieniędzy od zespołu Keycloak (co byłoby trudne, biorąc pod uwagę, że to rozwiązanie open-source) – po prostu uważamy je za niezwykle użyteczne.
Istnieje wiele sposobów na szybką i łatwą konfigurację Keycloak, co powinno zaspokoić potrzeby różnych użytkowników. Platforma obsługuje liczne standardy protokołów, takie jak OpenID Connect, OAuth 2.0 i SAML 2.0, dzięki czemu jest kompatybilna z różnymi aplikacjami. Takie podejście pozwala zaoferować funkcjonalność SSO (Single Sign-On) niezależnie od architektury Twojego rozwiązania.
Keycloak jest również skonteneryzowany, co czyni go idealnym rozwiązaniem dla środowisk opartych na kontenerach, takich jak Docker czy Kubernetes. Świadczy o tym wiele cech tej platformy, w tym:
Dzięki tym funkcjom Keycloak jest jednym z najpopularniejszych rozwiązań Identity and Access Management (IAM). Aby lepiej zapoznać się z tematem Keycloak i szczegółowo zrozumieć wartość jego stosowania, zachęcam do przeczytania artykułu Keycloak SSO – zalety Single Sign-On i gotowego systemu zarządzania dostępem opublikowanego na blogu Pretius (zawiera on darmowy Keycloak Cost Estimation Cheat Sheet). Możesz również sprawdzić nasze kompleksowe porównanie Okta vs Keycloak.
Aby zademonstrować zalety korzystania z Keycloak, skonfigurujemy serwer i zintegrujemy go z prostą aplikacją front-end napisaną w Angularze w wersji 17.
Będziesz musiał skonfigurować Keycloak. Jest to stosunkowo prosty proces dzięki dokumentacji, która prowadzi użytkownika krok po kroku przez kolejne etapy, więc nie będziemy pokazywać, jak to zrobić w tym artykule. Jedynym celem naszego serwera będzie zademonstrowanie tematów omówionych w artykule, więc nie potrzebujemy niczego więcej.
Będziemy pracować z aplikacją front-end stworzoną w Angular 17, więc zacznijmy od zaprezentowania bibliotek, które pozwalają na korzystanie z Keycloak. Zastosowaliśmy dwie:
💀 Wciąż pracujesz ze starym frameworkiem AngularJS? Dowiedz się, jak zaktualizować swoje aplikacje z AngularJS do nowego Angulara.
Na potrzeby tego artykułu musimy mieć możliwość wylogowania się i bycia przekierowanym na dedykowaną stronę wylogowania. Ponadto nasza aplikacja musi implementować wsparcie dla podstawowych funkcjonalności zapewnianych przez Keycloak. Wyróżniliśmy następujące scenariusze, które powinny zostać zaimplementowane:
Zacznijmy od pobrania obrazu Keycloak dla Dockera z oficjalnej strony internetowej. Aby uruchomić Keycloak w lokalnym środowisku, po prostu użyj następującej komendy:
docker run -p 8080:8080 -e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=admin quay.io/keycloak/keycloak:23.0.4 start-dev
Po wykonaniu tej komendy możesz przejść do panelu Keycloak pod adresem http://localhost:8080. Aby przeprowadzić wymaganą konfigurację, postępuj zgodnie z wytycznymi na oficjalnej stronie Keycloak. Po wprowadzeniu wszystkich zmian po prostu pozostaw proces Keycloak uruchomiony w konsoli, aby umożliwić komunikację z nim.
Realm, który utworzyliśmy na potrzeby tego tutoriala, został nazwany Pretius-Keycloak-FE-Integration, natomiast wybrany client id to keycloak-angular-integration-tutorial.
Musisz również utworzyć nowy projekt Angular dla swojej aplikacji front-endowej, korzystając z frameworka Angular 17. Aby to zrobić, otwórz konsolę i przejdź do katalogu, w którym chcesz utworzyć projekt. Następnie wprowadź komendę ng new i nazwę naszego projektu, jak przedstawiono poniżej:
ng new keycloak-fe-integration
Zostaniesz poproszony o informacje na temat funkcji, które mają zostać uwzględnione w początkowym projekcie. Wybierz opcje w zależności od potrzeb i preferencji lub zaakceptuj wartości domyślne.
W naszym projekcie używamy tych bibliotek w następujących wersjach:
Aby pobrać te biblioteki, wprowadź następującą komendę w terminalu w folderze projektu:
npm install keycloak-js@22 keycloak-angular@15 --save
Po zainstalowaniu niezbędnych pakietów npm i innych zależności wymaganych przez Angular, zostaniesz przywitany widokiem swojego obszaru roboczego z katalogiem głównym o nazwie keycloak-fe-integration (jeśli użyłeś tej samej nazwy co my). Kolejnym krokiem będzie zastąpienie istniejącej struktury plików tą wskazaną poniżej:
Jak widzisz, wszystkie strony zostały podzielone w zależności od ich celu w folderze pages. Przed omówieniem właściwej logiki, zacznijmy od zaprezentowania zawartości folderu pages, który zawiera komponenty reprezentujące strony w aplikacji. Główną stroną aplikacji, na którą użytkownik jest przekierowywany po pierwszym uruchomieniu, jest main-page. Przyjrzyjmy się zatem logice, która za nią stoi:
@Component({
selector: 'app-main-page',
standalone: true,
imports: [NgIf],
styleUrl: './main-page.component.scss',
template: `<div class="content">
<span class="title">Main page</span>
</div>
<a
*ngIf="!isLoggedIn"
role="button"
class="button"
(click)="redirectToLoginPage()"
>
Log In
</a>`,
})
export class MainPageComponent {
get isLoggedIn(): boolean {
return this.authenticationService.isLoggedIn();
}
constructor(private readonly authenticationService: AuthenticationService) {}
redirectToLoginPage(): void {
this.authenticationService.redirectToLoginPage();
}
}
Komponent wyświetla jedynie informację o bieżącej lokalizacji użytkownika w tytule i udostępnia przycisk pozwalający na zalogowanie się przy użyciu Keycloak.
Kolejnym komponentem do analizy jest unprotected-route:
@Component({
selector: 'app-unprotected-route',
standalone: true,
imports: [CommonModule],
template: `
<div class="content">
<span class="title">Welcome {{ username }}!</span>
<span class="status-text">This is an unprotected route</span>
</div>
`
})
export class UnprotectedRouteComponent {
get username(): string {
return this.authenticationService.isLoggedIn()
? this.authenticationService.userName
: 'friend';
}
constructor(readonly authenticationService: AuthenticationService) {}
}
Jak widzisz, ten komponent skupia się jedynie na wyświetlaniu imienia użytkownika, gdy użytkownik jest zalogowany. W przeciwnym razie otrzymasz ciąg znaków friend.
Jeśli spojrzysz następnie na komponent protected-route, również zauważysz, że skupia się on jedynie na wyświetlaniu prostych danych:
@Component({
selector: 'app-protected-route',
standalone: true,
template: `
<div class="content">
<span class="title">Welcome {{ authenticationService.userName }}!</span>
<span class="status-text">This is a protected route</span>
</div>
`
})
export class ProtectedRouteComponent {
constructor(readonly authenticationService: AuthenticationService) {}
}
Również w przypadku dwóch ostatnich komponentów znajdziesz jedynie prosty kod odpowiedzialny za wyświetlanie zwykłego kodu HTML. Poniżej znajduje się zawartość folderu not-found :
@Component({
selector: 'app-not-found',
standalone: true,
template: `<h1>Page not found</h1>`
})
export class NotFoundComponent {}
A oto logout-screen wyświetlany, gdy użytkownik wyloguje się z aplikacji:
@Component({
selector: 'app-logout-screen',
standalone: true,
template: `
<div class="content">
<span class="title">You have been logged out!</span>
</div>`
})
export class LogoutScreenComponent {}
Jak można wywnioskować z powyższych elementów kodu, poszczególne strony nie wpływają na komunikację między Keycloak a front-endem. Przygotowując przewodnik, kierowaliśmy się zasadą nieumieszczania logiki w komponentach. Można ją znaleźć jedynie w guardach chroniących dostęp do odpowiednich stron oraz w serwisie zawierającym logikę odpowiedzialną za komunikację między aplikacją Angular a Keycloak. W dalszej części artykułu omówimy najważniejsze elementy i ich rolę w systemie.
Po pomyślnym zainstalowaniu biblioteki keycloak-angular , możesz skonfigurować moduł Keycloak w aplikacji front-endowej. Najpierw zdefiniuj zmienne środowiskowe używane wewnątrz aplikacji. Aby to zrobić, utwórz plik, np. environment.ts, w głównym katalogu projektu. Poniżej znajdują się zmienne użyte podczas tworzenia naszego projektu:
export const environment = {
production: false,
keycloak: {
authority: 'http://localhost:8080',
redirectUri: 'http://localhost:4200',
postLogoutRedirectUri: 'http://localhost:4200/logout',
realm: 'Pretius-Keycloak-FE-Integration',
clientId: 'keycloak-angular-integration-tutorial',
},
idleConfig: { idle: 10, timeout: 60, ping: 10 },
};
Dokładny cel tych zmiennych wyjaśnimy w kolejnych sekcjach. W skrócie reprezentują one informacje dotyczące konfiguracji serwera Keycloak, z którym będzie się łączyć aplikacja Angular.
Aby zapewnić inicjalizację Keycloak podczas uruchamiania aplikacji, dodaj token APP_INITIALIZER i zdefiniuj funkcję do uruchomienia w czasie działania aplikacji, a następnie dodaj ją do AppModule, aby inicjalizacja Keycloak odbyła się z odpowiednią konfiguracją. W naszej aplikacji użyliśmy rozwiązania aplikacji modularnej. Zawartość tego modułu przedstawiono poniżej:
export const initializeKeycloak = (keycloak: KeycloakService) => async () =>
keycloak.init({
config: {
url: environment.keycloak.authority,
realm: environment.keycloak.realm,
clientId: environment.keycloak.clientId,
},
loadUserProfileAtStartUp: true,
initOptions: {
onLoad: 'check-sso',
silentCheckSsoRedirectUri:
window.location.origin + '/assets/silent-check-sso.html',
checkLoginIframe: false,
redirectUri: environment.keycloak.redirectUri,
},
});
@NgModule({
bootstrap: [AppComponent],
declarations: [AppComponent],
imports: [
RouterModule.forRoot(routes),
BrowserModule,
KeycloakAngularModule,
CommonModule,
HttpClientModule,
NavigationBarComponent,
FooterComponent,
],
providers: [
{
provide: APP_INITIALIZER,
useFactory: initializeKeycloak,
multi: true,
deps: [KeycloakService],
},
provideUserIdleConfig({
idle: environment.idleConfig.idle,
ping: environment.idleConfig.ping,
timeout: environment.idleConfig.timeout,
}),
],
})
export class AppModule {}
Ten kod pozwala na skonfigurowanie wsparcia Keycloak wewnątrz aplikacji. Funkcja initializeKeycloak() jest tutaj kluczowa, ponieważ odpowiada za poprawną inicjalizację tej usługi. Musisz upewnić się, że dane jej dostarczone dokładnie odzwierciedlają konfigurację podaną w Keycloak. Aby to zrobić, ustaw następujące wartości w obiekcie config:
Musisz również ustawić loadUserProfileAtStartUp, aby wymusić na aplikacji pobieranie danych o aktualnie zalogowanym użytkowniku podczas jej ładowania. Bez tego ustawienia, po zalogowaniu się użytkownika, jego dane nie będą dostępne. Oznacza to, że aby z nich skorzystać, konieczne będzie ręczne ich pobranie.
Kolejnym obiektem, który należy skonfigurować, jest initOptions. Jest to obiekt konfiguracyjny pozwalający na dostosowanie działania i inicjalizacji Keycloak. Atrybuty, które ustawiliśmy, to:
Wartość window.location.origin + /assets/silent-check-sso.html wskazuje lokalizację pliku statycznej strony HTML, która jest używana do cichego sprawdzania SSO. Ten plik umożliwia komunikację przez iframe między aplikacją a Keycloak. Aby to zrobić, utwórz ten plik w określonej lokalizacji i umieść w nim następujący kod:
<html> <body> <script> parent.postMessage(location.href, location.origin); </script> </body> </html>
Dostępne opcje mogą się różnić w zależności od wersji Keycloak i specyfiki aplikacji. Sprawdź dokumentację Keycloak , aby uzyskać najbardziej aktualne informacje.
Po prawidłowym zainicjowaniu i skonfigurowaniu modułu do komunikacji z Keycloak, możesz korzystać z udostępnianych przez niego funkcji. W tym celu utwórz osobny serwis authorization.service.ts, który zapewni Ci wymagane metody do korzystania z Keycloak wewnątrz aplikacji. Ponieważ chcesz mieć tylko jedną instancję tego serwisu w swojej aplikacji (singleton), użyj standardowego podejścia przy tworzeniu serwisów przez Angular CLI i zostaw dekorator @Injectable({ providedIn: 'root’ }). Następnie w konstruktorze wstrzyknij serwis z biblioteki keycloak-angular :
constructor(private readonly keycloakService: KeycloakService) {}
Mając przygotowany serwis, przejdźmy do implementacji kilku przydatnych metod. Pierwszą będzie metoda pozwalająca użytkownikom na zalogowanie się do aplikacji. Zatem utwórz metodę redirectToLoginPage() :
redirectToLoginPage(): Promise<void> {
this.keycloakService.login();
}
Teraz przejdź do implementacji pozostałych metod. Na potrzeby tego projektu będziesz wymagać informacji o nazwie użytkownika, statusie logowania oraz możliwości wylogowania się w aplikacji. Implementacja poszczególnych metod została przedstawiona poniżej:
get userName(): string {
return this.keycloakService.getUsername();
}
isLoggedIn(): boolean {
return this.keycloakService.isLoggedIn();
}
logout(): void {
this.keycloakService.logout(environment.keycloak.postLogoutRedirectUri);
}
Jak widzisz, API wystawione przez keycloak-angular pozwala na łatwą implementację wszystkich tych wymagań poprzez wywoływanie odpowiednich metod na stronie Keycloak. Warto zwrócić uwagę na metodę logout, w której można przekazać parametr definiujący ścieżkę, na którą użytkownik zostanie przekierowany po wylogowaniu z aplikacji. Tak jak wcześniej, ten parametr również definiujesz przy użyciu zmiennych środowiskowych.
Jeśli chcesz również zaimplementować automatyczne wylogowanie użytkownika po określonym czasie bezczynności, możesz to osiągnąć wywołując metodę logout, na przykład przy użyciu zewnętrznej biblioteki monitorującej aktywność użytkownika. Zademonstrujemy ten efekt przy użyciu biblioteki angular-user-idle. Po zakończeniu konfiguracji zgodnie z instrukcjami zawartymi w oficjalnej dokumentacji modułu, dodaj następujący kod do pliku app.component.ts :
ngOnInit(): void {
if (this.authenticationService.isLoggedIn()) {
this.userIdleService.startWatching();
this.userIdleService
.onTimerStart()
.pipe(takeUntilDestroyed(this.destroyRef))
.subscribe();
this.userIdleService
.onTimeout()
.pipe(takeUntilDestroyed(this.destroyRef))
.subscribe(() => {
alert('Your session has timed out. Please log in again.');
this.authenticationService.logout();
this.userIdleService.resetTimer();
});
}
}
Zaprezentowana przez nas funkcja ma na celu monitorowanie aktywności użytkownika dopiero po jego zalogowaniu. Takie podejście pozwala na automatyczne wylogowanie użytkownika z aplikacji po określonym czasie, a następnie wyświetlenie odpowiedniej informacji na ten temat. Należy jednak pamiętać o zresetowaniu timera przy wywoływaniu tej funkcji. W przeciwnym razie alert będzie pojawiał się w sposób ciągły, uniemożliwiając użytkownikowi wylogowanie.
Po zintegrowaniu z serwerem Keycloak kolejnym krokiem jest utworzenie routingu aplikacji i zapewnienie odpowiedniej kontroli dostępu do poszczególnych serwisów. Aby to zrobić, przeanalizujmy przygotowany plik app.routes.ts , w którym wymienione są poszczególne podstrony, a każdej z nich przypisana jest odpowiednia kontrola dostępu przy użyciu guarda canActivate :
export enum AppRoutes {
Main = '',
Protected = 'protected',
Unprotected = 'unprotected',
Logout = 'logout',
NotFound = '404',
}
export const routes: Routes = [
{
path: AppRoutes.Main,
pathMatch: 'full',
component: MainPageComponent,
},
{
path: AppRoutes.Protected,
canActivate: [AuthGuard],
component: ProtectedRouteComponent,
},
{
path: AppRoutes.Unprotected,
component: UnprotectedRouteComponent,
},
{
path: AppRoutes.Logout,
canActivate: [LogoutRouteGuard],
component: LogoutScreenComponent,
},
{
path: AppRoutes.NotFound,
component: NotFoundComponent,
},
{
path: '**',
redirectTo: AppRoutes.NotFound,
},
];
Wszystkie podstrony naszej aplikacji zostały przedstawione powyżej. Analizując kod, skup się na kluczowych fragmentach obsługi logiki związanej z autoryzacją. Aby zarządzać dostępem tylko do wybranych stron, użyj guardów na poszczególnych trasach, do których nie chcesz, aby miały dostęp osoby niezalogowane. Przykładem takiej strony jest strona Protected chroniona przez AuthGuard. Zobaczmy zatem, jak działa ten guard:
export const AuthGuard: CanActivateFn = (): boolean => {
const authenticationService = inject(AuthenticationService);
if (authenticationService.isLoggedIn()) {
return true;
}
authenticationService.redirectToLoginPage();
return false;
};
Powyższy guard sprawdza, czy użytkownik jest zalogowany przy próbie wejścia na chronioną stronę. Robisz to za pomocą metody isLoggedIn() , która sprawdza czy istnieje aktywna sesja dla obecnego użytkownika i w zależności od wyniku przekierowuje użytkownika na wybraną stronę lub – w przypadku braku aktywnej sesji – do strony logowania. Drugą rzeczą, na którą warto zwrócić uwagę, jest strona, na którą następuje przekierowanie po wylogowaniu. Tutaj również można użyć guarda do zarządzania dostępem i ograniczenia możliwości przeglądania jej przez użytkownika, który nadal posiada aktywną sesję w Keycloak. Aby to zrobić, wystarczy użyć metody isLoggedIn() udostępnianej przez authorizationService.
export const LogoutRouteGuard: CanActivateFn = () => {
const authenticationService = inject(AuthenticationService);
const router = inject(Router);
if (!authenticationService.isLoggedIn()) {
return true;
} else {
return router.createUrlTree([AppRoutes.Main]);
}
};
Jeśli użytkownik posiada aktywną sesję, guard przekieruje go na stronę główną.
Aby sprawdzić czy aplikacja działa tak jak powinna, należy potwierdzić poprawność scenariuszy opisanych na początku artykułu. Zacznijmy od wyświetlenia strony głównej aplikacji bez logowania. Najpierw uruchommy naszą aplikację następującą komendą:
ng serve
Teraz otwórz dowolną przeglądarkę i przejdź pod adres http://localhost:4200. Powinna pojawić się strona główna aplikacji:
Jak widzisz, wszystko uruchomiło się prawidłowo. Dostępne nam ścieżki są wyświetlane w prawym górnym rogu. Przejdźmy więc do kolejnej strony klikając przycisk Unprotected :
Tutaj również aplikacja pozwala na przekierowanie nawet bez aktywnej sesji w Keycloak. Sprawdźmy więc ostatnią dostępną opcję, czyli naciśnijmy przycisk Login :
W wyniku tej akcji aplikacja poprawnie przekierowuje nas do strony logowania Keycloak. Wprowadź zatem dane użytkownika i sprawdź, czy zostaniesz poprawnie uwierzytelniony.
Po zalogowaniu powinieneś wylądować na stronie głównej, gdzie powinieneś teraz zobaczyć informację o poprawnym uwierzytelnieniu. Zobaczmy jak wyglądają strony Protected i Unprotected po zalogowaniu do aplikacji:
Aplikacja pozwala na swobodny dostęp do strony Protected , na której wyświetlana jest informacja z imieniem zalogowanego użytkownika. Następnie sprawdźmy również stronę Unprotected :
Strona Unprotected również wyświetla teraz imię zalogowanego użytkownika, co potwierdza poprawną autoryzację. Teraz, gdy użytkownik spróbuje przejść na ścieżkę /logout posiadając aktywną sesję, zgodnie z przyjętą logiką, powinien zostać przeniesiony z powrotem na stronę główną. Aby się wylogować, kliknij przycisk Logout w prawym górnym rogu aplikacji:
Po jego naciśnięciu lądujesz na stronie informującej o wylogowaniu, zgodnie z konfiguracją jaką podaliśmy Keycloak. Jak widzisz, nie posiadasz już aktywnej sesji, o czym świadczy tekst statusu logowania pod tytułem strony. Jeśli na tym etapie spróbujesz wrócić do strony chronionej, czyli Protected w naszym przypadku, aplikacja automatycznie przekieruje Cię do strony logowania Keycloak.
Co się stanie, jeśli przez dłuższy czas nie wykonasz żadnej akcji i zostaniesz uwierzytelniony po zalogowaniu? Spróbuj nic nie robić przez czas wskazany w konfiguracji modułu z biblioteki angular-user-idle . Po upływie tego czasu zostaniesz powitany alertem informującym o wylogowaniu z sesji z powodu bezczynności, a po jego potwierdzeniu zostaniesz przekierowany do Dashboard bez aktywnej sesji.
W kontekście aplikacji opartej na Angular, konfiguracja autoryzacji end-to-end z Keycloak spełnia wymagania kontroli dostępu i zapewnia wygodne oraz spójne doświadczenie dla użytkownika końcowego. Co więcej, ten system IAM pozwala rozwiać wszelkie potencjalne obawy dotyczące standardów bezpieczeństwa danych aplikacji. Zespół ds. bezpieczeństwa Keycloak dba o Twój spokojny sen poprzez stałe monitorowanie zagrożeń i wydawanie poprawek chroniących przed nimi.
Proces integracji jest również bardzo prosty dzięki dostępnym bibliotekom (keycloak-angular , keycloak-js ). API wydane przez keycloak-angular zostało przygotowane tak, aby oferować wszystko, czego deweloperzy mogą wymagać podczas tworzenia aplikacji. Z tym artykułem powinieneś być zdolny do skonfigurowania kompleksowego narzędzia, które chroni aplikację przed dowolnym niepożądanym scenariuszem. Także niewątpliwą zaletą bibliotek keycloak-js i keycloak-angular jest bez wątpienia szczegółowa dokumentacja jaką oferują. Dzięki niej zrozumienie jak działa integracja i jak ją wdrożyć jest relatywnie prostym zadaniem.
Jeśli myślisz o wdrożeniu Keycloak w swojej firmie, rozważ skontaktowanie się z nami. Ukończyliśmy wiele projektów Keycloak klasy enterprise dla naszych klientów i chętnie podzielimy się z Tobą kilkoma case study oraz oszacujemy możliwe koszty wdrożenia Keycloak. Takie wstępne konsultacje są w Pretius zawsze bezpłatne, więc po prostu daj nam znać o swoich potrzebach – możesz użyć poniższego formularza kontaktowego lub napisać do nas na adres hello@pretius.com.
Jeśli interesuje Cię Keycloak lub Angular, możesz również sprawdzić inne artykuły na blogu Pretius:
