Основы Identity and Access Management (IAM) в архитектуре приложений

Привет, Хабр!

С каждым годом мы становимся свидетелями все большего количества сбоев в системах безопасности, утечек данных и хакерских атак даже на самые маленькие проекты.

Identity and Access Management (IAM) выступает как наша первая линия обороны. Оно не просто защищает наши данные, но и гарантирует, что правильные люди имеют доступ к нужной информации в нужное время. Каждая вторая транзакция в мире происходит онлайн, безопасность становится не просто приоритетом, а необходимостью.

IAM — это комплексная система, охватывающая многие процессы, которые организация использует для управления идентификацией пользователей и их доступом к различным ресурсам.

Основные компоненты и процессы

1. Идентификация

Идентификация — это процесс, в ходе которого пользователь представляется системе, обычно путем ввода уникального идентификатора (например, имени пользователя). Идентификатор обычно связан с профилем пользователя в базе данных IAM, содержащем информацию о пользователе и его роли в системе.

2. Аутентификация

Аутентификация — это процесс проверки утверждения пользователя о своей идентичности.

Методы аутентификации: Включают в себя что-то, что знает пользователь (пароль), что-то, что у пользователя есть (токен, смарт-карта), что-то, что является частью пользователя ( например биометрические данные).

Многофакторная аутентификация (MFA): Объединяет два или более методов аутентификации для повышения безопасности.

Многофакторная аутентификация (MFA) увеличивает безопасность, требуя от пользователя предоставить два или более фактора аутентификации. Эти факторы обычно делятся на что-то, что пользователь знает (пароль), что-то, что у пользователя есть (телефон, токен), и что-то, что является частью пользователя (биометрия).

Имитация процесса MFA с использованием пароля и одноразового пароля (OTP), отправленного на телефон пользователя:

import pyotp import getpass  def generate_otp(secret):     totp = pyotp.TOTP(secret)     return totp.now()  def verify_password(user_password):     # Это просто пример. В реальном приложении пароль должен быть захеширован и проверен с хешированным паролем в базе данных.     return user_password == "UserSecretPassword"  def verify_otp(user_otp, secret):     totp = pyotp.TOTP(secret)     return totp.verify(user_otp)  # Имитация процесса MFA user_password = getpass.getpass("Введите ваш пароль: ") if verify_password(user_password):     secret = "MFRGGZDFMZTWQ2LK"  # Этот секрет должен быть уникальным для каждого пользователя и храниться в безопасности     otp = generate_otp(secret)     print(f"Ваш одноразовый пароль: {otp}")     user_otp = input("Введите одноразовый пароль: ")     if verify_otp(user_otp, secret):         print("Аутентификация прошла успешно!")     else:         print("Неверный одноразовый пароль.") else:     print("Неверный пароль.") 

SAML, OAuth, OpenID Connect

Эти протоколы обеспечивают аутентификацию и обмен данными между системами.

SAML (Security Assertion Markup Language) используется для обмена аутентификационными и авторизационными данными между сторонами. OAuth — это протокол, который позволяет приложениям получать ограниченный доступ к учетным записям пользователей. OpenID Connect — это слой идентификации поверх OAuth 2.0.

Имитация клиентского приложения OAuth:

import requests  client_id = 'YOUR_CLIENT_ID' client_secret = 'YOUR_CLIENT_SECRET' authorization_url = 'https://example.com/oauth/authorize' token_url = 'https://example.com/oauth/token' redirect_uri = 'https://yourapp.com/callback'  # Получение кода авторизации auth_response = requests.get(authorization_url, {'response_type': 'code', 'client_id': client_id, 'redirect_uri': redirect_uri}) auth_code = auth_response.json()['code']  # Обмен кода авторизации на токен доступа token_response = requests.post(token_url, {'grant_type': 'authorization_code', 'code': auth_code, 'client_id': client_id, 'client_secret': client_secret, 'redirect_uri': redirect_uri}) access_token = token_response.json()['access_token']  print(f"Токен доступа: {access_token}") 

3. Авторизация

Авторизация определяет, какие действия или ресурсы доступны аутентифицированному пользователю.

Ролевой доступ (RBAC): Пользователи назначаются ролям, каждая из которых связана с определенными правами доступа.

В модели ролевого доступа пользователи назначаются ролям, и каждая роль связана с определенными правами доступа. Это позволяет централизованно управлять правами доступа, назначая пользователям роли вместо индивидуальных прав.

RBAC с использованием классов и декораторов для контроля доступа:

class User:     def __init__(self, roles):         self.roles = roles  def has_role(role):     def decorator(f):         def wrapper(user, *args, **kwargs):             if role in user.roles:                 return f(user, *args, **kwargs)             else:                 raise Exception("Недостаточно прав доступа")         return wrapper     return decorator  @has_role('admin') def delete_user(user, target_user_id):     print(f"Пользователь {target_user_id} удален.")  # Создание пользователя с определенными ролями admin_user = User(['admin', 'user'])  # Попытка выполнения действия try:     delete_user(admin_user, target_user_id=1234) except Exception as e:     print(e) 

Основанный на атрибутах доступ (ABAC): Доступ предоставляется на основе атрибутов (характеристик) пользователя, ресурса, действия и контекста.

В ABAC доступ предоставляется на основе атрибутов пользователя, ресурса, действия и контекста. Это позволяет создавать более динамичные и тонко настроенные политики доступа.

Реализация ABAC с использованием функций и условий:

def access_control(user_attributes, resource_attributes, action):     if user_attributes['role'] == 'admin':         return True     if user_attributes['department'] == resource_attributes['department'] and action == 'read':         return True     return False  user_attributes = {'role': 'user', 'department': 'sales'} resource_attributes = {'department': 'sales'} action = 'read'  if access_control(user_attributes, resource_attributes, action):     print("Доступ разрешен.") else:     print("Доступ запрещен.") 

Политика безопасности: Определяет правила, которые управляют авторизацией, обычно в виде набора правил или условий.

4. Управление идентификацией

Управление идентификацией включает в себя создание, обновление, и удаление учетных записей пользователей и их атрибутов.

Управление учетными записями: Процессы для создания, модификации и удаления учетных записей в системах и приложениях.

Каталог служб: Централизованные репозитории для хранения и управления идентификационными данными (например, Active Directory).

Синхронизация и интеграция данных: Соединение различных систем и баз данных для обеспечения целостности данных пользователя.

5. Управление сессиями

Управление сессиями отслеживает активность аутентифицированного пользователя в системе.

Токены сессии: Используются для поддержания состояния сессии пользователя между запросами.

Timeouts и политики сессий: определяют, как долго пользователь может оставаться в системе без активности, предотвращая злоупотребления и утечки данных из-за забытых открытых сессий.

Имитация таймаута сессии:

import time  SESSION_TIMEOUT = 300  # 5 минут  last_activity_time = time.time()  def check_session():     if time.time() - last_activity_time > SESSION_TIMEOUT:         print("Сессия истекла.")         return False     print("Сессия активна.")     return True  # Имитация активности пользователя time.sleep(100)  # Пользователь неактивен 100 секунд  if check_session():     print("Выполнение действий в системе...") else:     print("Необходимо повторно войти в систему.")

6. Журналирование и мониторинг

Это база. Отслеживание и запись всех событий, связанных с идентификацией, аутентификацией, авторизацией и управлением доступом необходимо абсолютно везде и всегда.

Журналы аудита: Фиксация всех важных событий для последующего анализа.

Системы мониторинга: Непрерывное отслеживание для обнаружения необычных паттернов или потенциальных угроз.

7. Интеграция с другими системами

IAM должна быть интегрирована с другими системами и сервисами организации.

APIs и сервисы: Для обмена данными между IAM и другими системами.

Федеративная идентификация: Позволяет пользователям использовать одни и те же учетные данные для доступа к различным системам.

IAM — это не статичная система, а динамичный набор процессов, об этом важно помнить.

Значение IAM для архитектуры приложений

Особенности IAM для трех типов архитектур: монолитная, микросервисная и облачная:

Монолитная архитектура:

1. Централизованный контроль доступа: В монолитных приложениях, где все компоненты находятся в одной системе, можно реализовать централизованный контроль доступа. IAM позволяет определить роли и разрешения для пользователей, работающих внутри монолита.

2. Ограниченные интеграции: Монолиты редко интегрируются с внешними системами для аутентификации, так как они представляют из себя единую систему. Это упрощает настройку IAM.

3. Ограниченная масштабируемость: Монолиты могут иметь ограниченную масштабируемость, что влияет на способы управления доступом. IAM здесь в первую очередь ориентировано на управление внутренними пользователями и ролями.

Это может выглядеть так:

# Псевдокод примера реалзации IAM в монолитном приложении class User:     def __init__(self, username, roles):         self.username = username         self.roles = roles  class IAM:     def __init__(self):         self.users = []      def add_user(self, user):         self.users.append(user)      def check_access(self, user, resource):         # проверка доступа пользователя к ресурсу         if user.username in [u.username for u in self.users] and 'admin' in user.roles:             return True         return False  # к примеру можно использовать это таким образом: iam_system = IAM() user = User("admin_user", ["admin"]) iam_system.add_user(user) print(iam_system.check_access(user, "confidential_data")) 

Микросервисная архитектура:

1. Децентрализованный контроль доступа: В микросервисной архитектуре компоненты приложения разделены и могут быть распределены по разным серверам или контейнерам. IAM здесь должно поддерживать децентрализованный контроль доступа, где каждый микросервис может иметь свои правила доступа.

2. Интеграция с API Gateway: Часто микросервисные приложения используют API Gateway для маршрутизации запросов. IAM должно интегрироваться с API Gateway для обеспечения контроля доступа к микросервисам.

3. Динамическое масштабирование: Микросервисы легко масштабируются в зависимости от нагрузки. IAM должно учитывать эту динамику и обеспечивать безопасность при динамическом масштабировании.

Взаимодействие с IAM-сервисом через API:

import requests  class IAMService:     def __init__(self, iam_service_url):         self.iam_service_url = iam_service_url      def check_access(self, token, service_name):         response = requests.get(f"{self.iam_service_url}/check_access", params={"token": token, "service": service_name})         return response.json()["access_granted"]  # Пример использования iam_service = IAMService("http://iam-service.com") access_token = "user_access_token" print(iam_service.check_access(access_token, "orders_service"))

Облачная архитектура:

1. Интеграция с облачными поставщиками: Облачные приложения используют инфраструктуру облачных поставщиков (например, AWS, Azure, Google Cloud). IAM должно интегрироваться с инструментами и службами облачных поставщиков для обеспечения безопасности и управления доступом.

2. Доступ к ресурсам в облаке: IAM в облачных архитектурах позволяет управлять доступом к различным облачным ресурсам, таким как виртуальные машины, хранилища данных, базы данных и другие.

3. Гибкий и масштабируемый: IAM в облачных архитектурах обычно более гибкое и масштабируемое, позволяя настраивать доступ на уровне ресурсов, пользователей и групп пользователей.

4. Мониторинг и аудит: Облачные поставщики предоставляют инструменты мониторинга и аудита, которые можно интегрировать с IAM для отслеживания и анализа действий пользователей.

Интеграция с IAM сервисами облачного провайдера, например, AWS IAM:

import boto3  def check_user_access(aws_access_key_id, aws_secret_access_key, resource_arn):     iam_client = boto3.client('iam', aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key)     response = iam_client.simulate_principal_policy(PolicySourceArn=resource_arn, ActionNames=['iam:ListUsers'])     return response['EvaluationResults'][0]['EvalDecision'] == 'allowed'  # Пример использования aws_access_key_id = 'YOUR_AWS_ACCESS_KEY_ID' aws_secret_access_key = 'YOUR_AWS_SECRET_ACCESS_KEY' resource_arn = 'arn:aws:iam::123456789012:user/SomeUser' print(check_user_access(aws_access_key_id, aws_secret_access_key, resource_arn)) 

В мире, где каждый байт данных имеет значение, выбор подходящего инструмента для Identity and Access Management (IAM) становится критически важным решением для любой организации. Давайте погрузимся в обзор популярных инструментов IAM, таких как Okta и Auth0, и рассмотрим ключевые критерии для выбора наиболее подходящего решения IAM для конкретной архитектуры.

Инструменты для реализации IAM:

Okta

Okta — это облачная платформа IAM, предлагающая широкий спектр функций для управления идентификацией и доступом. Она поддерживает интеграцию с множеством приложений и сервисов, обеспечивает многофакторную аутентификацию, управление доступом на основе политик и обширные возможности по аудиту и отчетности.

Особенности:

• Интеграция с более чем 6,000 приложений.

• Функционал Single Sign-On (SSO).

• Поддержка многофакторной аутентификации.

• Удобный интерфейс управления пользователями.

Auth0

Auth0 предлагает гибкую платформу для аутентификации и авторизации, позволяя разработчикам легко интегрировать IAM в любые приложения. Auth0 поддерживает различные протоколы и стандарты, такие как OAuth 2.0, OpenID Connect и SAML.

Особенности:

• Поддержка широкого спектра протоколов идентификации.

• Настраиваемые потоки аутентификации и авторизации.

• Встроенные инструменты для безопасности, включая MFA.

• Интеграция с многочисленными языками и фреймворками.

Microsoft Azure Active Directory

Microsoft Azure Active Directory (Azure AD) — это облачный сервис IAM от Microsoft, тесно интегрированный с другими продуктами Microsoft, такими как Office 365 и Azure. Он предоставляет набор функций для управления пользователями и группами, а также для безопасной аутентификации и авторизации.

Особенности:

• Глубокая интеграция с продуктами Microsoft.

• Поддержка стандартов безопасности, таких как MFA и условный доступ.

• Управление идентификаторами для современных и легаси-приложений.

Кстати, можно глянуть их гит и в целом понять, что из себя представляет Azure: https://github.com/AzureAD

Идентификационные данные

Представляют собой информацию, которая идентифицирует конкретного пользователя или субъекта в системе IAM.

Особенности идентификационных данных:

1. Уникальность: Идентификационные данные должны быть уникальными для каждого пользователя или субъекта. Это позволяет идентифицировать и разграничивать доступ между разными субъектами.

2. Конфиденциальность: Данные, используемые для идентификации, должны быть конфиденциальными и защищенными от несанкционированного доступа. К ним могут относиться логины, пароли, биометрические данные и т.п.

3. Актуальность: Информация в идентификационных данных должна быть актуальной. Если пользователь меняет контактные данные или статус в организации, это должно быть отражено в его идентификационных данных.

Для повышения безопасности часто используется многофакторная аутентификация, где идентификационные данные состоят из нескольких факторов, таких как пароль и биометрические данные

Базовая структура идентификационных данных может выглядеть так:

class IdentityData:     def __init__(self, user_id, username, email):         self.user_id = user_id  # Уникальный идентификатор пользователя         self.username = username  # Логин пользователя         self.email = email  # Адрес электронной почты пользователя         self.is_active = True  # Статус активности учетной записи (по умолчанию активна) 

Класс IdentityData может использоваться для представления идентификационных данных пользователя. Он включает в себя уникальный идентификатор, логин, адрес электронной почты и статус активности учетной записи. Конечно, в real life структура данных будет более сложной и может включать дополнительные поля в зависимости от конкретных требований организации

Взаимодействие системы Identity and Access Management (IAM) с системами обнаружения вторжений (IDS), антивирусами и протоколами шифрования представляет собой ключевой аспект обеспечения безопасности информационных ресурсов организации. В данной статье мы рассмотрим, как IAM интегрируется и взаимодействует с этими системами для обеспечения комплексной защиты данных и сетей.

IAM и системы обнаружения вторжений (IDS)

Системы обнаружения вторжений (IDS) предназначены для мониторинга сетевой активности и выявления аномальных или вредоносных действий. Взаимодействие IAM с IDS позволяет улучшить обнаружение и реагирование на угрозы.

IAM может интегрироваться с IDS для передачи данных об активности пользователей, изменениях в правах доступа и попытках несанкционированного доступа. Это обеспечивает централизованный мониторинг и позволяет быстро реагировать на подозрительные события. Системы IAM могут предоставлять информацию о пользователях, их ролях и действиях. IDS использует эту информацию для более точной идентификации потенциальных угроз, связанных с учетными записями. При обнаружении аномальной активности IDS может передавать информацию в IAM для временного ограничения доступа пользователя или для требования дополнительной аутентификации.

Антивирусные системы в свою очередь предназначены для обнаружения и блокировки вредоносных программ и кода. Интеграция с IAM способствует более надежной защите от угроз, связанных с вредоносным программным обеспечением. IAM может интегрироваться с антивирусами для автоматического сканирования файлов, загружаемых пользователями. Это позволяет предотвратить загрузку вредоносных файлов на серверы организации. Антивирусные системы могут проверять электронную почту и вложения на наличие вредоносных элементов. IAM может автоматически управлять доступом к подозрительным вложениям и предупреждать пользователей о потенциальных угрозах.

IAM может интегрироваться с протоколами шифрования для обеспечения безопасной аутентификации и авторизации. IAM может поддерживать протоколы шифрования, такие как TLS/SSL, для защиты передаваемых данных. IAM может защищать ключи шифрования, используемые для расшифровки данных.

Для реализации некоторых интеграций в Okta с IDS, антивирусными системами и протоколами шифрования, вам потребуется выполнить несколько шагов:

1. Интеграция Okta с IDS

Цель: Настроить передачу данных о пользовательских активностях из Okta в IDS для мониторинга и выявления подозрительных действий.

Шаги:

1. Выбор IDS: Убедитесь, что ваша система IDS совместима с Okta. Некоторые популярные IDS, такие как Splunk или AlienVault, имеют встроенную поддержку интеграции с Okta.

2. Настройка логов: В Okta перейдите в раздел ‘System Log’. Здесь вы найдете детальную информацию о пользовательских сессиях, попытках входа и изменениях в правах доступа.

3. Экспорт логов: Настройте автоматическую отправку логов из Okta в вашу систему IDS. Это может быть реализовано через API Okta или путем интеграции через сторонние сервисы, такие как Splunk HTTP Event Collector: Для этого вам потребуется доступ к Okta API и права администратора в Okta, можно следовать этим шагам:

1. Получение API токена в Okta:

   • Войдите в Okta Admin Dashboard.

   • Перейдите в раздел ‘Security’ > ‘API’.

   • Создайте новый токен, следуя инструкциям. Запишите этот токен, так как он понадобится для авторизации запросов к API.

2. Написание скрипта для получения Логов:

   • Используйте ЯП’s, поддерживающие HTTP запросы (например, Python).

   • Напишите скрипт, который будет делать запросы к эндпоинту /api/v1/logs Okta API, используя полученный API токен для аутентификации. Можно использовать этот:

import requests  def fetch_okta_logs(api_token, okta_domain, limit=100):     """     Получает логи через API Okta.      Параметры:     api_token (str): Токен API для аутентификации в API Okta.     okta_domain (str): Домен вашей организации Okta.     limit (int): Количество записей логов для получения. По умолчанию 100.      Возвращает:     list: Список записей логов из Okta.     """     # Эндпоинт API Okta для получения логов     url = f"https://{okta_domain}/api/v1/logs"      # Заголовки для аутентификации     headers = {         "Authorization": f"SSWS {api_token}",         "Accept": "application/json"     }      # Параметры для запроса API     params = {         "limit": limit     }      # Выполнение запроса к API     response = requests.get(url, headers=headers, params=params)      # Проверка успешности запроса     if response.status_code == 200:         return response.json()     else:         raise Exception(f"Ошибка получения логов: {response.status_code} - {response.text}")  # Пример использования # api_token = "ваш_api_token" # okta_domain = "ваш_okta_domain" # logs = fetch_okta_logs(api_token, okta_domain) # print(logs)

3. Передача данных в IDS: Настройте скрипт таким образом, чтобы он передавал полученные логи в вашу систему IDS. Для передачи данных в систему обнаружения вторжений (IDS) из Okta, вы можете использовать скрипт, который сначала извлекает логи из Okta, а затем отправляет их в IDS. Однако, конкретная реализация будет зависеть от того, какую систему IDS вы используете. Рассмотрим общий пример, используя Python, для отправки логов из Okta в IDS, например, в Splunk с использованием Splunk HTTP Event Collector.

Для этого примера, предположим, что у вас уже есть скрипт для извлечения логов из Okta, как описано ранее. Теперь дополним его функциональностью для отправки этих логов в Splunk.

Необходимые данные:

• Splunk HTTP Event Collector URL

• Splunk HTTP Event Collector Token

• Okta API Token

• Okta Domain

Скрипт:

import requests import json  def fetch_okta_logs(api_token, okta_domain, limit=100):     url = f"https://{okta_domain}/api/v1/logs"     headers = {"Authorization": f"SSWS {api_token}", "Accept": "application/json"}     params = {"limit": limit}     response = requests.get(url, headers=headers, params=params)      if response.status_code == 200:         return response.json()     else:         raise Exception(f"Error fetching logs: {response.status_code} - {response.text}")  def send_logs_to_splunk(logs, splunk_collector_url, splunk_token):     headers = {         "Authorization": f"Splunk {splunk_token}",         "Content-Type": "application/json"     }     for log in logs:         response = requests.post(splunk_collector_url, headers=headers, data=json.dumps(log))         if response.status_code not in [200, 201, 202]:             raise Exception(f"Error sending log to Splunk: {response.status_code} - {response.text}")  # ПРИМЕр использования # api_token = "your_okta_api_token" # okta_domain = "your_okta_domain" # splunk_collector_url = "your_splunk_collector_url" # splunk_token = "your_splunk_token" # logs = fetch_okta_logs(api_token, okta_domain) # send_logs_to_splunk(logs, splunk_collector_url, splunk_token) 

Использование скрипта:

Замените your_okta_api_token, your_okta_domain, your_splunk_collector_url, и your_splunk_token на соответствующие значения, которые вы используете. Запустите скрипт, чтобы он извлекал логи из Okta и отправлял их в Splunk.

Обратите внимание, что конкретные детали, такие как формат логов и методы их отправки, могут варьироваться в зависимости от вашей конкретной настройки Splunk и требований безопасности.

Обзорный пример реализации IAM с Okta

Шаг 1: Регистрация в Okta

Первым шагом является регистрация в Okta и создание учетной записи администратора. После успешной регистрации вы получите доступ к панели управления Okta.

Шаг 2: Создание приложения в Okta

1. Войдите в панель управления Okta.

2. Перейдите во вкладку «Applications» и нажмите «Add Application».

3. Выберите тип приложения, например, «Web».

4. Укажите настройки приложения, такие как URL перенаправления.

5. Сохраните настройки и получите Client ID и Client Secret.

Шаг 3: Установка библиотеки Okta

Для взаимодействия с Okta из вашего приложения установите библиотеку Okta.

pip install okta

Шаг 4: Инициализация клиента Okta

Используйте полученные Client ID и Client Secret для инициализации клиента Okta в вашем приложении.

from okta.auth import Client as AuthClient from okta.users import Client as UsersClient  auth_client = AuthClient("https://your-okta-domain.okta.com", "your-client-id", "your-client-secret") users_client = UsersClient("https://your-okta-domain.okta.com", "your-client-id", "your-client-secret")

Шаг 5: Регистрация пользователей

Добавьте функциональность регистрации пользователей в вашем приложении. После успешной регистрации, создайте учетные записи пользователей в Okta.

from okta.models.user import User  def register_user(username, password, email):     user = User(login=username, email=email, password=password)     user = users_client.create_user(user, activate=True)     return user

Шаг 6: Аутентификация пользователей

Реализуйте процесс аутентификации пользователей с использованием Okta.

def authenticate_user(username, password):     try:         auth_result = auth_client.authenticate(username, password)         if auth_result.status == "SUCCESS":             return True         else:             return False     except Exception as e:         print(f"Authentication failed: {str(e)}")         return False

Шаг 7: Ролевой доступ (RBAC)

Настройте ролевой доступ для пользователей, определяя разные роли и их права доступа в Okta.

from okta.models.role import Role  def create_role(name, description):     role = Role(type="USER", name=name, description=description)     role = auth_client.create_role(role)     return role

Шаг 8: Многофакторная аутентификация (MFA)

Настройте многофакторную аутентификацию для повышения безопасности.

from okta.models.factor import Factor  def enable_mfa(user_id):     factors = auth_client.get_available_user_factors(user_id)     for factor in factors:         if factor.factorType == "sms":             auth_client.activate_user_factor(user_id, factor.id)

Шаг 9: Управление жизненным циклом идентификационных данных

Добавьте функциональность управления данными пользователей, включая обновление информации и смену паролей.

def update_user_info(user_id, new_email):     user = users_client.get_user(user_id)     user.profile.email = new_email     user.update()

Шаг 10: Интеграция в приложение

Интегрируйте Okta в ваше приложение для обеспечения безопасности и управления доступом.

from okta_jwt.jwt import validate_token  def protect_route(request):     auth_header = request.headers.get("Authorization")     if auth_header:         token = auth_header.split("Bearer ")[1]         try:             validate_token(token, "your-okta-client-id", "your-okta-domain")             return "Access granted"         except Exception as e:             return "Access denied"     else:         return "Access denied"

Заключение

IAM обеспечивает безопасность, эффективность и управляемость вашего приложения.

Напомню о том, что у моих друзей из OTUS есть ряд актуальных практических курсов по информационной безопасности от действующих экспертов отрасли. Если вы заинтересованы в получении новых знаний, переходите в каталог и выбирайте подходящее направление.