keystoneauth1.identity.v3 package¶

子模块¶

模块内容¶

class keystoneauth1.identity.v3.ApplicationCredential(auth_url: str, application_credential_secret: str, application_credential_id: str | None = None, application_credential_name: str | None = None, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None, *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

继承自 Auth

使用应用程序凭据进行身份验证的插件。

参数：

auth_url (string) – 身份服务端点，用于身份验证。
application_credential_secret (string) – 应用程序凭据密钥。
application_credential_id (string) – 应用程序凭据 ID。
application_credential_name (string) – 应用程序凭据名称。
username (string) – 身份验证的用户名。
user_id (字符串) – 用于身份验证的用户 ID。
user_domain_id (字符串) – 用于身份验证的用户的域 ID。
user_domain_name (字符串) – 用于身份验证的用户的域名称。
reauthenticate (bool) – 允许在当前令牌即将过期时获取新的令牌。（可选）默认值为 True

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = "A plugin for authenticating with an application credential.\n\n :param string auth_url: Identity service endpoint for authentication.\n :param string application_credential_secret: Application credential secret.\n :param string application_credential_id: Application credential ID.\n :param string application_credential_name: Application credential name.\n :param string username: Username for authentication.\n :param string user_id: User ID for authentication.\n :param string user_domain_id: User's domain ID for authentication.\n :param string user_domain_name: User's domain name for authentication.\n :param bool reauthenticate: Allow fetching a new token if the current one\n is going to expire. (optional) default True\n "

__init__(auth_url: str, application_credential_secret: str, application_credential_id: str | None = None, application_credential_name: str | None = None, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None, *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True) → None

__module__ = 'keystoneauth1.identity.v3.application_credential'

_abc_impl = <_abc._abc_data object>

_auth_method_class: 别名 ApplicationCredentialMethod

class keystoneauth1.identity.v3.ApplicationCredentialMethod(*, application_credential_secret: str, application_credential_id: str | None = None, application_credential_name: str | None = None, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None)

基类: AuthMethod

构造一个基于用户/密码的身份验证方法。

参数：

application_credential_secret (string) – 应用程序凭据密钥。
application_credential_id (string) – 应用凭证 ID。
application_credential_name (string) – 应用凭证的名称，如果未提供 ID。
username (string) – 用于身份验证的用户名，如果未提供应用凭证 ID。
user_id (string) – 用于身份验证的用户 ID，如果未提供应用凭证 ID。
user_domain_id (string) – 用于身份验证的用户域 ID，如果未提供应用凭证 ID。
user_domain_name (string) – 用于身份验证的用户域名称，如果未提供应用凭证 ID。

__abstractmethods__ = frozenset({})

__annotations__ = {'_method_parameters': 'list[str] | None', 'application_credential_id': str | None, 'application_credential_name': str | None, 'application_credential_secret': <class 'str'>, 'user_domain_id': str | None, 'user_domain_name': str | None, 'user_id': str | None, 'username': str | None}

__doc__ = "构造基于用户/密码的认证方法。\n\n :param string application_credential_secret: 应用程序凭证密钥。\n :param string application_credential_id: 应用程序凭证 ID。\n :param string application_credential_name: 应用程序的名称，如果未提供 ID。\n 凭证。\n :param string username: 用于认证的用户名，如果未提供应用程序 ID。\n 凭证 ID。\n :param string user_id: 用于认证的用户 ID，如果未提供应用程序 ID。\n 凭证 ID。\n :param string user_domain_id: 用于认证的用户域 ID，如果未提供应用程序 ID。\n 凭证 ID。\n :param string user_domain_name: 用于认证的用户域名称，如果未提供应用程序 ID。\n 凭证 ID。\n "

__init__(*, application_credential_secret: str, application_credential_id: str | None = None, application_credential_name: str | None = None, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None) → None

__module__ = 'keystoneauth1.identity.v3.application_credential'

_abc_impl = <_abc._abc_data object>

application_credential_id: str | None = None

application_credential_name: str | None = None

application_credential_secret: str

get_auth_data(session: Session, auth: Auth, headers: dict[str, str], request_kwargs: dict[str, object]) → tuple[None, None] | tuple[str, Mapping[str, object]]

返回身份验证插件的身份验证部分。

参数：

session (keystoneauth1.session.Session) – 会话。
auth (base.Auth) – 调用该方法的认证插件。
headers (dict) – 将与身份验证请求一起发送的标头（如果插件需要添加标头）。

返回值:

此插件的标识符和用于身份验证类型的字典数据。

返回类型:

tuple(string, dict)

get_cache_id_elements() → dict[str, str | None]

获取使该认证方法唯一化的元素。

这些元素将用作 keystoneauth1.plugin.BaseIdentityPlugin.get_cache_id() 的一部分，以允许缓存认证插件的状态。

如果希望允许缓存其状态，插件应重写此方法。

为避免冲突或覆盖，返回字典的键应以插件标识符为前缀。例如，密码插件将其用户名值作为“password_username”返回。

user_domain_id: str | None = None

user_domain_name: str | None = None

user_id: str | None = None

username: str | None = None

class keystoneauth1.identity.v3.Auth(auth_url: str, auth_methods: list[AuthMethod], *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

基础类: BaseAuth

Identity V3 身份验证插件。

参数：

auth_url (string) – 身份服务端点，用于身份验证。
auth_methods (list) – 用于身份验证的方法集合。
trust_id (string) – 信任范围的信任 ID。
domain_id (string) – 域 ID，用于域范围限定。
domain_name (string) – 域名称，用于域范围限定。
project_id (string) – 项目 ID，用于项目范围限定。
project_name (string) – 项目名称，用于项目范围限定。
project_domain_id (string) – 项目的域 ID，用于项目。
project_domain_name (string) – 项目的域名称，用于项目。
reauthenticate (bool) – 允许在当前令牌即将过期时获取新的令牌。（可选）默认值为 True
include_catalog (bool) – 在返回的令牌中包含服务目录。（可选）默认值为 True。
unscoped (bool) – 强制返回未范围限定的令牌。即使此用户的 default_project_id 已设置，也会使 Keystone 服务器返回未范围限定的令牌。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = "Identity V3 身份验证插件。\n\n :param 字符串 auth_url: 身份验证的身份服务端点。\n :param 列表 auth_methods: 用于身份验证的方法集合。\n :param 字符串 trust_id: 信任范围的信任 ID。\n :param 字符串 domain_id: 域范围的域 ID。\n :param 字符串 domain_name: 域范围的域名称。\n :param 字符串 project_id: 项目范围的项目 ID。\n :param 字符串 project_name: 项目范围的项目名称。\n :param 字符串 project_domain_id: 项目的域 ID。\n :param 字符串 project_domain_name: 项目的域名称。\n :param 布尔值 reauthenticate: 如果当前令牌即将过期，则允许获取新的令牌。\n (可选) 默认值为 True\n :param 布尔值 include_catalog: 在返回的令牌中包含服务目录。\n (可选) 默认值为 True。\n :param 布尔值 unscoped: 强制返回未范围化的令牌。即使为该用户设置了 default_project_id，Keystone 服务器也会返回未范围化的令牌。\n "

__init__(auth_url: str, auth_methods: list[AuthMethod], *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

__module__ = 'keystoneauth1.identity.v3.base'

_abc_impl = <_abc._abc_data object>

add_method(method: AuthMethod) → None: 添加一个额外的已初始化 AuthMethod 实例。

get_auth_ref(session: Session) → AccessInfoV3

从 OpenStack Identity 服务获取令牌。

此方法由各种令牌版本插件覆盖。

不应独立调用此函数，并预计通过 do_authenticate 函数调用。

如果插件缓存的 AccessInfo 对象无效，将调用此函数。因此，插件应始终在调用时获取新的 AccessInfo。如果您只想检索当前的身份验证数据，则应使用 get_access。

参数：

session (keystoneauth1.session.Session) – 可以用于通信的会话对象。

引发:

keystoneauth1.exceptions.response.InvalidResponse – 返回的响应不合适。
keystoneauth1.exceptions.http.HttpError – 来自无效 HTTP 响应的错误。

返回值:

令牌访问信息。

返回类型:

keystoneauth1.access.AccessInfo

get_cache_id_elements() → dict[str, str | None]

获取使此身份验证插件唯一化的元素。

作为 get_cache_id 要求的一部分，我们需要确定此插件及其值的哪些方面构成唯一的元素。

插件希望允许缓存时应覆盖此方法。

返回值:: 此插件的唯一属性和值。
返回类型:: 一个扁平的字典，其中包含一个 str 键和一个 str 或 None 值。这需要我们将这些值馈送到哈希中。值为空的对在哈希 ID 中被忽略。

class keystoneauth1.identity.v3.AuthConstructor(auth_url: str, *args: Any, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True, **kwargs: Any)

继承自 Auth

创建 Auth 插件的抽象基类。

创建的 Auth 插件仅包含一种身份验证方法。这通常是必需的使用方式。

AuthConstructor 基于插件定义的 method_arguments 和 auth_method_class 创建 AuthMethod。然后，它使用该身份验证方法创建身份验证插件。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_auth_method_class': typing.ClassVar[type[keystoneauth1.identity.v3.base.AuthMethod]], '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = "抽象基类，用于创建 Auth 插件。\n\n 创建的 Auth 插件仅包含一种身份验证方法。这是通常需要的用法。\n\n AuthConstructor 根据方法的参数和插件定义的 auth_method_class 创建 AuthMethod。然后\n 它使用该身份验证方法创建身份验证插件。\n "

__init__(auth_url: str, *args: Any, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True, **kwargs: Any)

__module__ = 'keystoneauth1.identity.v3.base'

_abc_impl = <_abc._abc_data object>

_auth_method_class: ClassVar[type[AuthMethod]]

class keystoneauth1.identity.v3.AuthMethod(**kwargs: object)

基类: object

V3 身份验证策略的一部分。

v3 ‘/tokens’ API 允许多种方法在向服务器进行身份验证时呈现。这些方法中的每一个都由 AuthMethod 实现。

注意：在实现 AuthMethod 时，请使用关键字参数以确保 MultiFactor 身份验证插件支持它们。

__abstractmethods__ = frozenset({'get_auth_data'})

__annotations__ = {"_method_parameters": list[str] | None}

__dict__ = mappingproxy({'__module__': 'keystoneauth1.identity.v3.base', '__annotations__': {'_method_parameters': list[str] | None}, '__doc__': "一个 V3 身份验证策略的一部分。\n\n v3 '/tokens' API 允许在向服务器进行身份验证时呈现多种方法。这些方法中的每一个都由\n AuthMethod 实现。\n\n 注意：在实现 AuthMethod 时，请使用关键字参数以确保它们\n 受 MultiFactor 身份验证插件的支持。\n ", '_method_parameters': None, '__init__': <function AuthMethod.__init__>, '_extract_kwargs': <classmethod(<function AuthMethod._extract_kwargs>)>, 'get_auth_data': <function AuthMethod.get_auth_data>, 'get_cache_id_elements': <function AuthMethod.get_cache_id_elements>, '__dict__': <attribute '__dict__' of 'AuthMethod' objects>, '__weakref__': <attribute '__weakref__' of 'AuthMethod' objects>, '__abstractmethods__': frozenset({'get_auth_data'}), '_abc_impl': <_abc._abc_data object>})

__doc__ = "一个 V3 身份验证策略的一部分。\n\n v3 '/tokens' API 允许在向服务器进行身份验证时呈现多种方法。这些方法中的每一个都由\n AuthMethod 实现。\n\n 注意：在实现 AuthMethod 时，请使用关键字参数以确保它们\n 受 MultiFactor 身份验证插件的支持。\n "

__init__(**kwargs: object)

__module__ = 'keystoneauth1.identity.v3.base'

__weakref__: 对该对象的弱引用列表

_abc_impl = <_abc._abc_data object>

classmethod _extract_kwargs(kwargs: dict[str, object]) → dict[str, object]: 从其他 kwargs 中移除与此方法相关的参数。

_method_parameters: list[str] | None = None: 用于定义插件支持的参数的已弃用参数。这些现在应由类型化的类属性定义。

abstract get_auth_data(session: Session, auth: Auth, headers: dict[str, str], request_kwargs: dict[str, object]) → tuple[None, None] | tuple[str, Mapping[str, object]]

返回身份验证插件的身份验证部分。

参数：

session (keystoneauth1.session.Session) – 会话。
auth (base.Auth) – 调用该方法的认证插件。
headers (dict) – 将与身份验证请求一起发送的标头（如果插件需要添加标头）。

返回值:

此插件的标识符和用于身份验证类型的字典数据。

返回类型:

tuple(string, dict)

get_cache_id_elements() → dict[str, str | None]

获取使该认证方法唯一化的元素。

这些元素将用作 keystoneauth1.plugin.BaseIdentityPlugin.get_cache_id() 的一部分，以允许缓存认证插件的状态。

如果希望允许缓存其状态，插件应重写此方法。

为避免冲突或覆盖，返回字典的键应以插件标识符为前缀。例如，密码插件将其用户名值作为“password_username”返回。

class keystoneauth1.identity.v3.BaseAuth(auth_url: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

基础类: BaseIdentityPlugin

Identity V3 身份验证插件。

参数：

auth_url (string) – 身份服务端点，用于身份验证。
trust_id (string) – 信任范围的信任 ID。
system_scope (字符串) – 要限定的系统信息。
domain_id (string) – 域 ID，用于域范围限定。
domain_name (string) – 域名称，用于域范围限定。
project_id (string) – 项目 ID，用于项目范围限定。
project_name (string) – 项目名称，用于项目范围限定。
project_domain_id (string) – 项目的域 ID，用于项目。
project_domain_name (string) – 项目的域名称，用于项目。
reauthenticate (bool) – 允许在当前令牌即将过期时获取新的令牌。（可选）默认值为 True
include_catalog (bool) – 在返回的令牌中包含服务目录。（可选）默认值为 True。

__abstractmethods__ = frozenset({'get_auth_ref'})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': <class 'str'>, 'reauthenticate': 'bool'}

__doc__ = "身份验证 V3 插件。\n\n :param 字符串 auth_url: 身份验证的身份服务端点。\n :param 字符串 trust_id: 信任范围的信任 ID。\n :param 字符串 system_scope: 要限定的系统信息。\n :param 字符串 domain_id: 域范围的域 ID。\n :param 字符串 domain_name: 域范围的域名称。\n :param 字符串 project_id: 项目范围的项目 ID。\n :param 字符串 project_name: 项目范围的项目名称。\n :param 字符串 project_domain_id: 项目的域 ID。\n :param 字符串 project_domain_name: 项目的域名称。\n :param 布尔值 reauthenticate: 如果当前令牌即将过期，是否获取新的令牌。（可选）默认为 True\n :param 布尔值 include_catalog: 是否在返回的令牌中包含服务目录。（可选）默认为 True。\n "

__init__(auth_url: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

__module__ = 'keystoneauth1.identity.v3.base'

_abc_impl = <_abc._abc_data object>

auth_url: str

property has_scope_parameters: bool: 返回 true 如果参数可用于创建作用域令牌。

property token_url: str: 我们将发送身份验证数据的完整 URL。

class keystoneauth1.identity.v3.FederationBaseAuth(auth_url: str, identity_provider: str, protocol: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

基础类: _Rescoped

联合身份验证插件。

参数：

auth_url (string) – 身份服务 URL
identity_provider (string) – 客户端将进行身份验证的身份提供程序名称。此参数将用于构建用于获取未作用域 OpenStack 令牌的动态 URL。
protocol (string) – 客户端将要进行身份验证的协议名称。

__abstractmethods__ = frozenset({'get_unscoped_auth_ref'})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = '联合身份验证插件。\n\n :param auth_url: 身份服务的 URL\n :type auth_url: 字符串\n :param identity_provider: 客户端将要针对其进行身份验证的身份提供者的名称。此参数\n 将用于构建用于获取未作用域的 OpenStack 令牌的动态 URL。\n :type identity_provider: 字符串\n :param protocol: 客户端将要进行身份验证的协议名称。\n :type protocol: 字符串\n\n '

__init__(auth_url: str, identity_provider: str, protocol: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

__module__ = 'keystoneauth1.identity.v3.federation'

_abc_impl = <_abc._abc_data object>

property federated_token_url: str: 发送授权数据的完整 URL。

class keystoneauth1.identity.v3.Keystone2Keystone(base_plugin: BaseIdentityPlugin, service_provider: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

基础类: _Rescoped

插件用于执行 Keystone 到 Keystone 身份验证流程。

在此插件中，由 keystone 身份提供程序 (IdP) 提供的 ECP 封装的 SAML 断言用于向 keystone 服务提供程序 (SP) 请求 OpenStack 未作用域的令牌。

参数：

base_plugin (keystoneauth1.identity.v3.base.BaseAuth) – 已经过身份验证的 keystone IdP 的身份验证插件。
service_provider (str) – 服务提供程序 ID，如 ServiceProviderManager.list() 返回。

HTTP_MOVED_TEMPORARILY = 302

HTTP_SEE_OTHER = 303

REQUEST_ECP_URL = '/auth/OS-FEDERATION/saml2/ecp': 应将 ECP 封装的 SAML 断言呈现给 Keystone 服务提供程序的路径。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = '插件用于执行 Keystone 到 Keystone 身份验证流程。\n\n 在此插件中，由 keystone 身份提供程序 (IdP) 提供的 ECP 封装的 SAML 断言用于向\n keystone 服务提供程序 (SP) 请求 OpenStack 未作用域的令牌。\n\n :param base_plugin: 已经过身份验证的 keystone\n IdP 的身份验证插件。\n :type base_plugin: keystoneauth1.identity.v3.base.BaseAuth\n\n :param service_provider: 服务提供程序 ID，如\n ServiceProviderManager.list() 返回。\n :type service_provider: str\n\n '

__init__(base_plugin: BaseIdentityPlugin, service_provider: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

__module__ = 'keystoneauth1.identity.v3.k2k'

_abc_impl = <_abc._abc_data object>

_get_ecp_assertion(session: Session) → str

classmethod _remote_auth_url(auth_url: str) → str

返回远程 Keystone 服务提供程序的 auth_url。

远程云的 auth_url 是用于获取联合的无范围令牌的端点，通常是 https://remote.example.com:5000/v3/OS-FEDERATION/identity_providers/ <idp>/protocols/<protocol_id>/auth。但是我们需要生成一个真实的 auth_url，用于令牌范围限定。此函数假定服务提供程序属性中存储了今天的静态值，并且可以使用这些值作为分隔符。如果 sp_auth_url 不符合标准的联合身份验证 url，该函数将简单地返回整个字符串。

参数：: auth_url (str) – 远程云的 auth_url
返回值:: 远程云的 auth_url，可以在那里验证或范围限定令牌。
返回类型:: str

_send_service_provider_ecp_authn_response(session: Session, sp_url: str, sp_auth_url: str) → Response

将 ECP 封装的 SAML 断言呈现给 keystone SP。

断言由 keystone IdP 发出，其目标是作为服务提供程序将服务的 keystone。

参数：

session – 用于发送 HTTP 请求的会话对象。
sp_url (str) – 将 ECP 封装的 SAML 断言呈现给 keystone SP 的 URL。通常，类似于：https://sp.com/Shibboleth.sso/SAML2/ECP
sp_auth_url (str) – keystone SP 的联合身份验证 URL。由 IdP 指定，例如：https://sp.com/v3/OS-FEDERATION/identity_providers/ idp_id/protocols/protocol_id/auth

get_unscoped_auth_ref(session: Session) → AccessInfoV3: 获取未范围限定的联合令牌。

class keystoneauth1.identity.v3.MultiFactor(auth_url: str, auth_methods: list[str], *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True, **kwargs: Any)

继承自 Auth

用于使用多种身份验证方法进行身份验证的插件。

参数：

auth_url (string) – 身份服务端点，用于身份验证。
auth_methods (字符串) – 要进行身份验证的方法的名称。
trust_id (string) – 信任范围的信任 ID。
system_scope (字符串) – 要限定的系统信息。
domain_id (string) – 域 ID，用于域范围限定。
domain_name (string) – 域名称，用于域范围限定。
project_id (string) – 项目 ID，用于项目范围限定。
project_name (string) – 项目名称，用于项目范围限定。
project_domain_id (string) – 项目的域 ID，用于项目。
project_domain_name (string) – 项目的域名称，用于项目。
reauthenticate (bool) – 允许在当前令牌即将过期时获取新的令牌。（可选）默认值为 True

还接受基于指定了哪些方法而变化的各种关键字参数。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = "用于使用多种身份验证方法进行身份验证的插件。\n\n ：参数字符串 auth_url: 身份验证的身份服务端点。\n ：参数字符串 auth_methods: 要进行身份验证的方法的名称。\n ：参数字符串 trust_id: 信任范围的信任 ID。\n ：参数字符串 system_scope: 要限定的系统信息。\n ：参数字符串 domain_id: 域范围的域 ID。\n ：参数字符串 domain_name: 域范围的域名称。\n ：参数字符串 project_id: 项目范围的项目 ID。\n ：参数字符串 project_name: 项目范围的项目名称。\n ：参数字符串 project_domain_id: 项目的域 ID。\n ：参数字符串 project_domain_name: 项目的域名称。\n ：参数布尔值 reauthenticate: 如果当前令牌即将过期，则允许获取新的令牌。（可选）默认值为 True\n\n 还接受基于指定了哪些方法而变化的各种关键字参数。\n "

__init__(auth_url: str, auth_methods: list[str], *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True, **kwargs: Any)

__module__ = 'keystoneauth1.identity.v3.multi_factor'

_abc_impl = <_abc._abc_data object>

class keystoneauth1.identity.v3.OAuth2ClientCredential(auth_url: str, oauth2_endpoint: str, oauth2_client_id: str, oauth2_client_secret: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

继承自 Auth

一个用于通过 OAuth2.0 客户端凭据进行身份验证的插件。

参数：

auth_url (string) – 身份服务端点，用于身份验证。
oauth2_endpoint (string) – OAuth2.0 端点。
oauth2_client_id (string) – OAuth2.0 客户端凭据 ID。
oauth2_client_secret (string) – OAuth2.0 客户端凭据密钥。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = '一个用于通过 OAuth2.0 客户端凭据进行身份验证的插件。\n :param string auth_url: 身份服务端点，用于身份验证。\n :param string oauth2_endpoint: OAuth2.0 端点。\n :param string oauth2_client_id: OAuth2.0 客户端凭据 ID。\n :param string oauth2_client_secret: OAuth2.0 客户端凭据密钥。\n '

__init__(auth_url: str, oauth2_endpoint: str, oauth2_client_id: str, oauth2_client_secret: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True) → None

__module__ = 'keystoneauth1.identity.v3.oauth2_client_credential'

_abc_impl = <_abc._abc_data object>

_auth_method_class: 别名 OAuth2ClientCredentialMethod

get_headers(session: Session) → dict[str, str] | None

获取消息的身份验证头。

参数：: session (keystoneauth1.session.Session) – 该认证插件所属的会话对象。
返回值:: 用于验证消息的头，或者失败的 None。请注意，空字典是一个有效的、非失败的响应。
返回类型:: dict

class keystoneauth1.identity.v3.OAuth2ClientCredentialMethod(*, oauth2_endpoint: str, oauth2_client_id: str, oauth2_client_secret: str)

基类: AuthMethod

通过 OAuth2.0 客户端凭据获取令牌的身份验证方法。

参数：

oauth2_endpoint (string) – OAuth2.0 端点。
oauth2_client_id (string) – OAuth2.0 客户端凭据 ID。
oauth2_client_secret (string) – OAuth2.0 客户端凭据密钥。

__abstractmethods__ = frozenset({})

__annotations__ = {'_method_parameters': 'list[str] | None', 'oauth2_client_id': <class 'str'>, 'oauth2_client_secret': <class 'str'>, 'oauth2_endpoint': <class 'str'>}

__doc__ = '通过 OAuth2.0 客户端凭据获取令牌的身份验证方法。\n\n :param string oauth2_endpoint: OAuth2.0 端点。\n :param string oauth2_client_id: OAuth2.0 客户端凭据 ID。\n :param string oauth2_client_secret: OAuth2.0 客户端凭据密钥。\n '

__init__(*, oauth2_endpoint: str, oauth2_client_id: str, oauth2_client_secret: str) → None

__module__ = 'keystoneauth1.identity.v3.oauth2_client_credential'

_abc_impl = <_abc._abc_data object>

get_auth_data(session: Session, auth: Auth, headers: dict[str, str], request_kwargs: dict[str, object]) → tuple[None, None] | tuple[str, Mapping[str, object]]

返回身份验证插件的身份验证部分。

参数：

session (keystoneauth1.session.Session) – 会话。
auth (base.Auth) – 调用该方法的认证插件。
headers (dict) – 将与身份验证请求一起发送的标头（如果插件需要添加标头）。

返回值:

此插件的标识符和用于身份验证类型的字典数据。

返回类型:

tuple(string, dict)

get_cache_id_elements() → dict[str, str | None]

获取使该认证方法唯一化的元素。

这些元素将用作 keystoneauth1.plugin.BaseIdentityPlugin.get_cache_id() 的一部分，以允许缓存认证插件的状态。

如果希望允许缓存其状态，插件应重写此方法。

为避免冲突或覆盖，返回字典的键应以插件标识符为前缀。例如，密码插件将其用户名值作为“password_username”返回。

oauth2_client_id: str

oauth2_client_secret: str

oauth2_endpoint: str

class keystoneauth1.identity.v3.OAuth2mTlsClientCredential(auth_url: str, oauth2_endpoint: str, oauth2_client_id: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

基础类: BaseAuth

使用 OAuth2.0 mTLS 客户端凭据进行身份验证的插件。

参数：

auth_url (字符串) – keystone 授权端点。
oauth2_endpoint (string) – OAuth2.0 端点。
oauth2_client_id (string) – OAuth2.0 客户端凭据 ID。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = '使用 OAuth2.0 mTLS 客户端凭据进行身份验证的插件。\n\n :param 字符串 auth_url: keystone 授权端点。\n :param 字符串 oauth2_endpoint: OAuth2.0 端点。\n :param 字符串 oauth2_client_id: OAuth2.0 客户端凭据 id。\n '

__init__(auth_url: str, oauth2_endpoint: str, oauth2_client_id: str, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

__module__ = 'keystoneauth1.identity.v3.oauth2_mtls_client_credential'

_abc_impl = <_abc._abc_data object>

get_auth_ref(session: Session) → AccessInfoV3

从 OpenStack Identity 服务获取令牌。

此方法由各种令牌版本插件覆盖。

不应独立调用此函数，并预计通过 do_authenticate 函数调用。

参数：

session (keystoneauth1.session.Session) – 可以用于通信的会话对象。

引发:

keystoneauth1.exceptions.response.InvalidResponse – 返回的响应不合适。
keystoneauth1.exceptions.http.HttpError – 来自无效 HTTP 响应的错误。
keystoneauth1.exceptions.ClientException – 获取 OAuth2.0 访问令牌时出错。

返回值:

令牌访问信息。

返回类型:

keystoneauth1.access.AccessInfo

get_headers(session: Session) → dict[str, str] | None

获取消息的身份验证头。

参数：: session (keystoneauth1.session.Session) – 该认证插件所属的会话对象。
返回值:: 用于验证消息的头，或者失败的 None。请注意，空字典是一个有效的、非失败的响应。
返回类型:: dict

class keystoneauth1.identity.v3.OidcAccessToken(auth_url: str, identity_provider: str, protocol: str, access_token_type: str = 'access_token', scope: str = 'openid profile', access_token_endpoint: str | None = None, discovery_endpoint: str | None = None, access_token: str | None = None, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

继承自: _OidcBase

用于 OpenID Connect 访问令牌重用的实现。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', '_discovery_document': 'dict[str, object]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'grant_type': 'ty.ClassVar[str]', 'reauthenticate': 'bool'}

__doc__ = '用于 OpenID Connect 访问令牌重用的实现。'

__init__(auth_url: str, identity_provider: str, protocol: str, access_token_type: str = 'access_token', scope: str = 'openid profile', access_token_endpoint: str | None = None, discovery_endpoint: str | None = None, access_token: str | None = None, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

基于访问令牌的 OpenID Connect 插件。

它需要以下内容

参数：

auth_url (string) – 身份服务 URL
identity_provider (字符串) – 客户端将要进行身份验证的身份提供者的名称
protocol (字符串) – 在 keystone 中配置的协议名称
access_token (字符串) – OpenID Connect 访问令牌

__module__ = 'keystoneauth1.identity.v3.oidc'

_abc_impl = <_abc._abc_data object>

get_payload(session: Session) → dict[str, str | None]: OidcAccessToken 不需要负载。

get_unscoped_auth_ref(session: Session) → AccessInfoV3

使用 OpenID Connect 进行身份验证并获取声明。

我们会在访问受保护的 Keystone 端点（联合身份验证 URL）时交换访问令牌。这将触发 OpenID Connect 提供程序执行用户内省并检索有关用户的信息（在 scope 中指定），这些信息将以 OpenID Connect Claim 的形式发送到 Keystone，作为环境变量。

参数：: session (keystoneauth1.session.Session) – 用于发送 HTTP 请求的会话对象。
返回值:: 令牌数据表示形式
返回类型:: keystoneauth1.access.AccessInfoV3

class keystoneauth1.identity.v3.OidcAuthorizationCode(auth_url: str, identity_provider: str, protocol: str, client_id: str, client_secret: str, access_token_type: str = 'access_token', scope: str = 'openid profile', access_token_endpoint: str | None = None, discovery_endpoint: str | None = None, code: str | None = None, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True, redirect_uri: str | None = None)

继承自: _OidcBase

OpenID Connect 授权码的实现。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', '_discovery_document': 'dict[str, object]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'grant_type': 'ty.ClassVar[str]', 'reauthenticate': 'bool'}

__doc__ = 'OpenID Connect 授权码的实现。'

__init__(auth_url: str, identity_provider: str, protocol: str, client_id: str, client_secret: str, access_token_type: str = 'access_token', scope: str = 'openid profile', access_token_endpoint: str | None = None, discovery_endpoint: str | None = None, code: str | None = None, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True, redirect_uri: str | None = None)

开放ID授权码插件需要以下内容。

参数：

redirect_uri (字符串) – 开放ID Connect 客户端重定向 URL
code (字符串) – OAuth 2.0 授权码

__module__ = 'keystoneauth1.identity.v3.oidc'

_abc_impl = <_abc._abc_data object>

get_payload(session: Session) → dict[str, str | None]

获取“authorization_code”授权类型的授权。

参数：: session (keystoneauth1.session.Session) – 用于发送 HTTP 请求的会话对象。
返回值:: 一个 Python 字典，包含要交换的有效负载
返回类型:: dict

grant_type: ty.ClassVar[str] = 'authorization_code'

class keystoneauth1.identity.v3.OidcClientCredentials(auth_url: str, identity_provider: str, protocol: str, client_id: str, client_secret: str, access_token_type: str = 'access_token', scope: str = 'openid profile', access_token_endpoint: str | None = None, discovery_endpoint: str | None = None, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

继承自: _OidcBase

OpenID Connect 客户端凭据的实现。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', '_discovery_document': 'dict[str, object]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'grant_type': 'ty.ClassVar[str]', 'reauthenticate': 'bool'}

__doc__ = 'OpenID Connect 客户端凭据的实现。'

__init__(auth_url: str, identity_provider: str, protocol: str, client_id: str, client_secret: str, access_token_type: str = 'access_token', scope: str = 'openid profile', access_token_endpoint: str | None = None, discovery_endpoint: str | None = None, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

OpenID Connect 客户端凭据需要以下内容。

参数：

client_id – 用于身份验证的客户端 ID
client_secret – 用于身份验证的客户端密钥

__module__ = 'keystoneauth1.identity.v3.oidc'

_abc_impl = <_abc._abc_data object>

get_payload(session: Session) → dict[str, str | None]

获取客户端凭据授权类型的授权。

参数：: session (keystoneauth1.session.Session) – 用于发送 HTTP 请求的会话对象。
返回值:: 一个 Python 字典，包含要交换的有效负载
返回类型:: dict

grant_type: ty.ClassVar[str] = 'client_credentials'

class keystoneauth1.identity.v3.OidcPassword(auth_url: str, identity_provider: str, protocol: str, client_id: str, client_secret: str, access_token_type: str = 'access_token', scope: str = 'openid profile', access_token_endpoint: str | None = None, discovery_endpoint: str | None = None, username: str | None = None, password: str | None = None, idp_otp_key: str | None = None, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

继承自: _OidcBase

OpenID Connect 资源所有者密码凭证的实现。

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', '_discovery_document': 'dict[str, object]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'grant_type': 'ty.ClassVar[str]', 'reauthenticate': 'bool'}

__doc__ = 'OpenID Connect 资源所有者密码凭证的实现。'

__init__(auth_url: str, identity_provider: str, protocol: str, client_id: str, client_secret: str, access_token_type: str = 'access_token', scope: str = 'openid profile', access_token_endpoint: str | None = None, discovery_endpoint: str | None = None, username: str | None = None, password: str | None = None, idp_otp_key: str | None = None, *, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

OpenID 密码插件需要以下信息。

参数：

username (字符串) – 用于身份验证的用户名
password (字符串) – 用于身份验证的密码

__module__ = 'keystoneauth1.identity.v3.oidc'

_abc_impl = <_abc._abc_data object>

get_payload(session: Session) → dict[str, str | None]

获取“password”授权类型的授权。

参数：: session (keystoneauth1.session.Session) – 用于发送 HTTP 请求的会话对象。
返回值:: 一个 Python 字典，包含要交换的有效负载
返回类型:: dict

grant_type: ty.ClassVar[str] = 'password'

manage_otp_from_session_or_request_to_the_user(payload: dict[str, str | None], session: Session) → None

从会话中获取 OTP 代码，或者向用户请求。

当设置 OS_IDP_OTP_KEY 环境变量时，此方法将验证当前会话中是否存在 OTP 值，如果存在，我们将使用它（会话中的 OTP）在检索访问令牌时发送给身份提供者。如果当前会话中没有 OTP，我们会要求用户输入它（OTP），并将其添加到会话中以执行身份验证流程。

OTP 存储在会话中，因为在某些流程中，CLI 会执行两次身份验证过程，因此将 OTP 保存在会话中，允许我们在短时间内使用相同的 OTP，避免连续两次向用户请求它。

参数：

payload
会话

返回值:

class keystoneauth1.identity.v3.Password(auth_url: str, password: str, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None, *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

继承自 Auth

用于使用用户名和密码进行身份验证的插件。

参数：

auth_url (string) – 身份服务端点，用于身份验证。
password (string) – 身份验证的密码。
user_id (字符串) – 用于身份验证的用户 ID。
username (string) – 身份验证的用户名。
user_domain_id (字符串) – 用于身份验证的用户的域 ID。
user_domain_name (字符串) – 用于身份验证的用户的域名称。
trust_id (string) – 信任范围的信任 ID。
system_scope (字符串) – 要限定的系统信息。
domain_id (string) – 域 ID，用于域范围限定。
domain_name (string) – 域名称，用于域范围限定。
project_id (string) – 项目 ID，用于项目范围限定。
project_name (string) – 项目名称，用于项目范围限定。
project_domain_id (string) – 项目的域 ID，用于项目。
project_domain_name (string) – 项目的域名称，用于项目。
reauthenticate (bool) – 允许在当前令牌即将过期时获取新的令牌。（可选）默认值为 True

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = "使用用户名和密码进行身份验证的插件。\n\n :param 字符串 auth_url: 身份验证的身份服务端点。\n :param 字符串 password: 用于身份验证的密码。\n :param 字符串 user_id: 用于身份验证的用户 ID。\n :param 字符串 username: 用于身份验证的用户名。\n :param 字符串 user_domain_id: 用于身份验证的用户域 ID。\n :param 字符串 user_domain_name: 用于身份验证的用户域名称。\n :param 字符串 trust_id: 信任范围的信任 ID。\n :param 字符串 system_scope: 要作用域的系统信息。\n :param 字符串 domain_id: 域范围的域 ID。\n :param 字符串 domain_name: 域范围的域名称。\n :param 字符串 project_id: 项目范围的项目 ID。\n :param 字符串 project_name: 项目范围的项目名称。\n :param 字符串 project_domain_id: 项目的域 ID。\n :param 字符串 project_domain_name: 项目的域名称。\n :param 布尔值 reauthenticate: 如果当前令牌即将过期，则允许获取新的令牌。（可选）默认为 True\n "

__init__(auth_url: str, password: str, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None, *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True) → None

__module__ = 'keystoneauth1.identity.v3.password'

_abc_impl = <_abc._abc_data object>

_auth_method_class: 别名 PasswordMethod

类 keystoneauth1.identity.v3.PasswordMethod(*, password: str, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None)

基类: AuthMethod

构造基于用户/密码的身份验证方法。

参数：

password (string) – 身份验证的密码。
username (string) – 身份验证的用户名。
user_id (字符串) – 用于身份验证的用户 ID。
user_domain_id (字符串) – 用于身份验证的用户的域 ID。
user_domain_name (字符串) – 用于身份验证的用户的域名称。

__abstractmethods__ = frozenset({})

__annotations__ = {'_method_parameters': 'list[str] | None', 'password': <class 'str'>, 'user_domain_id': str | None, 'user_domain_name': str | None, 'user_id': str | None, 'username': str | None}

__doc__ = "构造基于用户/密码的身份验证方法。\n\n :param 字符串 password: 用于身份验证的密码。\n :param 字符串 username: 用于身份验证的用户名。\n :param 字符串 user_id: 用于身份验证的用户 ID。\n :param 字符串 user_domain_id: 用于身份验证的用户域 ID。\n :param 字符串 user_domain_name: 用于身份验证的用户域名称。\n "

__init__(*, password: str, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None) → None

__module__ = 'keystoneauth1.identity.v3.password'

_abc_impl = <_abc._abc_data object>

get_auth_data(session: Session, auth: Auth, headers: dict[str, str], request_kwargs: dict[str, object]) → tuple[None, None] | tuple[str, Mapping[str, object]]

返回身份验证插件的身份验证部分。

参数：

session (keystoneauth1.session.Session) – 会话。
auth (base.Auth) – 调用该方法的认证插件。
headers (dict) – 将与身份验证请求一起发送的标头（如果插件需要添加标头）。

返回值:

此插件的标识符和用于身份验证类型的字典数据。

返回类型:

tuple(string, dict)

get_cache_id_elements() → dict[str, str | None]

获取使该认证方法唯一化的元素。

这些元素将用作 keystoneauth1.plugin.BaseIdentityPlugin.get_cache_id() 的一部分，以允许缓存认证插件的状态。

如果希望允许缓存其状态，插件应重写此方法。

为避免冲突或覆盖，返回字典的键应以插件标识符为前缀。例如，密码插件将其用户名值作为“password_username”返回。

password: str

user_domain_id: str | None = None

user_domain_name: str | None = None

user_id: str | None = None

username: str | None = None

class keystoneauth1.identity.v3.ReceiptMethod(*, receipt: str)

基类: AuthMethod

使用收据继续身份验证的 Auth 插件。

参数：: receipt (string) – 用于身份验证的收据。

__abstractmethods__ = frozenset({})

__annotations__ = {'_method_parameters': 'list[str] | None', 'receipt': <class 'str'>}

__doc__ = '使用收据继续身份验证的 Auth 插件。\n\n :param string receipt: 用于身份验证的收据。\n '

__init__(*, receipt: str) → None

__module__ = 'keystoneauth1.identity.v3.receipt'

_abc_impl = <_abc._abc_data object>

get_auth_data(session: Session, auth: Auth, headers: dict[str, str], request_kwargs: dict[str, object]) → tuple[None, None] | tuple[str, Mapping[str, object]]

将身份验证收据添加到 headers 中。

我们显式返回 None 以避免将其添加到请求方法或主体中。

get_cache_id_elements() → dict[str, str | None]

获取使该认证方法唯一化的元素。

这些元素将用作 keystoneauth1.plugin.BaseIdentityPlugin.get_cache_id() 的一部分，以允许缓存认证插件的状态。

如果希望允许缓存其状态，插件应重写此方法。

为避免冲突或覆盖，返回字典的键应以插件标识符为前缀。例如，密码插件将其用户名值作为“password_username”返回。

receipt: str

class keystoneauth1.identity.v3.TOTP(auth_url: str, passcode: str, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None, *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

继承自 Auth

使用用户名和 TOTP 密码进行身份验证的插件。

参数：

auth_url (string) – 身份服务端点，用于身份验证。
passcode (string) – 用于身份验证的 TOTP 密码。
user_id (字符串) – 用于身份验证的用户 ID。
username (string) – 身份验证的用户名。
user_domain_id (字符串) – 用于身份验证的用户的域 ID。
user_domain_name (字符串) – 用于身份验证的用户的域名称。
trust_id (string) – 信任范围的信任 ID。
domain_id (string) – 域 ID，用于域范围限定。
domain_name (string) – 域名称，用于域范围限定。
project_id (string) – 项目 ID，用于项目范围限定。
project_name (string) – 项目名称，用于项目范围限定。
project_domain_id (string) – 项目的域 ID，用于项目。
project_domain_name (string) – 项目的域名称，用于项目。
reauthenticate (bool) – 允许在当前令牌即将过期时获取新的令牌。（可选）默认值为 True

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = "使用用户名和 TOTP 密码进行身份验证的插件。\n\n :param string auth_url: 身份验证的身份服务端点。\n :param string passcode: 用于身份验证的 TOTP 密码。\n :param string user_id: 用于身份验证的用户 ID。\n :param string username: 用于身份验证的用户名。\n :param string user_domain_id: 用于身份验证的用户域 ID。\n :param string user_domain_name: 用于身份验证的用户域名称。\n :param string trust_id: 用于信任范围的信任 ID。\n :param string domain_id: 用于域范围的域 ID。\n :param string domain_name: 用于域范围的域名称。\n :param string project_id: 用于项目范围的项目 ID。\n :param string project_name: 用于项目范围的项目名称。\n :param string project_domain_id: 项目的域 ID。\n :param string project_domain_name: 项目的域名称。\n :param bool reauthenticate: 如果当前令牌即将过期，则允许获取新的令牌。（可选）默认值为 True\n "

__init__(auth_url: str, passcode: str, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None, *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True) → None

__module__ = 'keystoneauth1.identity.v3.totp'

_abc_impl = <_abc._abc_data object>

_auth_method_class: 别名 TOTPMethod

class keystoneauth1.identity.v3.TOTPMethod(*, passcode: str, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None)

基类: AuthMethod

构造一个基于用户/密码的身份验证方法。

参数：

passcode (string) – 用于身份验证的 TOTP 密码。
username (string) – 身份验证的用户名。
user_id (字符串) – 用于身份验证的用户 ID。
user_domain_id (字符串) – 用于身份验证的用户的域 ID。
user_domain_name (字符串) – 用于身份验证的用户的域名称。

__abstractmethods__ = frozenset({})

__annotations__ = {'_method_parameters': 'list[str] | None', 'passcode': <class 'str'>, 'user_domain_id': str | None, 'user_domain_name': str | None, 'user_id': str | None, 'username': str | None}

__doc__ = "构造基于用户/密码的身份验证方法。\n\n :param 字符串 passcode: 用于身份验证的 TOTP 密码。\n :param 字符串 username: 用于身份验证的用户名。\n :param 字符串 user_id: 用于身份验证的用户 ID。\n :param 字符串 user_domain_id: 用于身份验证的用户域 ID。\n :param 字符串 user_domain_name: 用于身份验证的用户域名称。\n "

__init__(*, passcode: str, user_id: str | None = None, username: str | None = None, user_domain_id: str | None = None, user_domain_name: str | None = None) → None

__module__ = 'keystoneauth1.identity.v3.totp'

_abc_impl = <_abc._abc_data object>

get_auth_data(session: Session, auth: Auth, headers: dict[str, str], request_kwargs: dict[str, object]) → tuple[None, None] | tuple[str, Mapping[str, object]]

返回身份验证插件的身份验证部分。

参数：

session (keystoneauth1.session.Session) – 会话。
auth (base.Auth) – 调用该方法的认证插件。
headers (dict) – 将与身份验证请求一起发送的标头（如果插件需要添加标头）。

返回值:

此插件的标识符和用于身份验证类型的字典数据。

返回类型:

tuple(string, dict)

get_cache_id_elements() → dict[str, str | None]

获取使该认证方法唯一化的元素。

这些元素将用作 keystoneauth1.plugin.BaseIdentityPlugin.get_cache_id() 的一部分，以允许缓存认证插件的状态。

如果希望允许缓存其状态，插件应重写此方法。

为避免冲突或覆盖，返回字典的键应以插件标识符为前缀。例如，密码插件将其用户名值作为“password_username”返回。

passcode: str

user_domain_id: str | None = None

user_domain_name: str | None = None

user_id: str | None = None

username: str | None = None

class keystoneauth1.identity.v3.Token(auth_url: str, token: str, *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True)

继承自 Auth

使用现有 Token 进行身份验证的插件。

参数：

auth_url (string) – 身份服务端点，用于身份验证。
token (字符串) – 用于认证的 Token。
trust_id (string) – 信任范围的信任 ID。
domain_id (string) – 域 ID，用于域范围限定。
domain_name (string) – 域名称，用于域范围限定。
project_id (string) – 项目 ID，用于项目范围限定。
project_name (string) – 项目名称，用于项目范围限定。
project_domain_id (string) – 项目的域 ID，用于项目。
project_domain_name (string) – 项目的域名称，用于项目。
reauthenticate (bool) – 允许在当前令牌即将过期时获取新的令牌。（可选）默认值为 True

__abstractmethods__ = frozenset({})

__annotations__ = {'MIN_TOKEN_LIFE_SECONDS': 'int', '_discovery_cache': 'dict[str, discover.Discover]', 'auth_ref': 'access.AccessInfo | None', 'auth_url': 'str', 'reauthenticate': 'bool'}

__doc__ = "使用现有的 Token 进行身份验证的插件。\n\n :param 字符串 auth_url: 身份验证的身份服务端点。\n :param 字符串 token: 用于身份验证的 Token。\n :param 字符串 trust_id: 信任范围的 Trust ID。\n :param 字符串 domain_id: 域范围的 Domain ID。\n :param 字符串 domain_name: 域范围的 Domain 名称。\n :param 字符串 project_id: 项目范围的 Project ID。\n :param 字符串 project_name: 项目范围的 Project 名称。\n :param 字符串 project_domain_id: 项目的 Domain ID。\n :param 字符串 project_domain_name: 项目的 Domain 名称。\n :param 布尔值 reauthenticate: 如果当前 Token 即将过期，则允许获取新的 Token。（可选）默认为 True\n "

__init__(auth_url: str, token: str, *, unscoped: bool = False, trust_id: str | None = None, system_scope: str | None = None, domain_id: str | None = None, domain_name: str | None = None, project_id: str | None = None, project_name: str | None = None, project_domain_id: str | None = None, project_domain_name: str | None = None, reauthenticate: bool = True, include_catalog: bool = True) → None

__module__ = 'keystoneauth1.identity.v3.token'

_abc_impl = <_abc._abc_data object>

_auth_method_class: 别名 TokenMethod

class keystoneauth1.identity.v3.TokenMethod(*, token: str)

基类: AuthMethod

构造一个 Auth 插件，用于从 token 获取 token。

参数：: token (字符串) – 用于认证的 Token。

__abstractmethods__ = frozenset({})

__annotations__ = {'_method_parameters': 'list[str] | None', 'token': <class 'str'>}

__doc__ = "构造一个 Auth 插件，用于从 Token 获取 Token。\n\n :param 字符串 token: 用于身份验证的 Token。\n "

__init__(*, token: str) → None

__module__ = 'keystoneauth1.identity.v3.token'

_abc_impl = <_abc._abc_data object>

get_auth_data(session: Session, auth: Auth, headers: dict[str, str], request_kwargs: dict[str, object]) → tuple[None, None] | tuple[str, Mapping[str, object]]

返回身份验证插件的身份验证部分。

参数：

session (keystoneauth1.session.Session) – 会话。
auth (base.Auth) – 调用该方法的认证插件。
headers (dict) – 将与身份验证请求一起发送的标头（如果插件需要添加标头）。

返回值:

此插件的标识符和用于身份验证类型的字典数据。

返回类型:

tuple(string, dict)

get_cache_id_elements() → dict[str, str | None]

获取使该认证方法唯一化的元素。

这些元素将用作 keystoneauth1.plugin.BaseIdentityPlugin.get_cache_id() 的一部分，以允许缓存认证插件的状态。

如果希望允许缓存其状态，插件应重写此方法。

为避免冲突或覆盖，返回字典的键应以插件标识符为前缀。例如，密码插件将其用户名值作为“password_username”返回。

token: str

基类: BaseAuthPlugin

用于使用 Tokenless Auth 进行身份验证的插件。

这用于 Tokenless 身份验证。诸如域名和项目 ID 之类的作用域信息将传递在标头中，并且令牌验证请求将根据提供的 HTTPS 证书以及作用域信息进行身份验证。

__abstractmethods__ = frozenset({})

__annotations__ = {'_discovery_cache': 'dict[str, discover.Discover]'}

__doc__ = '用于使用 Tokenless Auth 进行身份验证的插件。\n\n 这用于 Tokenless 身份验证。诸如域名和项目 ID 之类的作用域信息将传递在标头中，并且\n 令牌验证请求将根据提供的 HTTPS 证书以及作用域信息进行身份验证。\n '

TokenlessAuth 的初始化方法。

参数：

auth_url (字符串) – 用于身份验证的身份服务端点。URL 必须包含版本号，否则任何请求都将导致 404 NotFound 错误。
domain_id (string) – 域 ID，用于域范围限定。
domain_name (string) – 域名称，用于域范围限定。
project_id (string) – 项目 ID，用于项目范围限定。
project_name (string) – 项目名称，用于项目范围限定。
project_domain_id (string) – 项目的域 ID，用于项目。
project_domain_name (string) – 项目的域名称，用于项目。

__module__ = 'keystoneauth1.identity.v3.tokenless_auth'

_abc_impl = <_abc._abc_data object>

get_endpoint(session: ks_session.Session, service_type: str | None = None, **kwargs: Any) → str | None

返回服务的有效端点。

参数：

session (keystoneauth1.session.Session) – 可以用于通信的会话对象。
service_type (string) – 要查找端点的服务类型。如果未提供 service_type，则此插件将返回 None（失败）。

返回值:

有效的端点 URL 或不可用时为 None。

返回类型:

字符串或 None

get_headers(session: ks_session.Session) → dict[str, str] | None

获取消息的身份验证头。

为了在会话中未提供令牌时提供 tokenless auth 作用域标头，需要重写默认的 get_headers 方法。

参数：: session (keystoneauth1.session.Session) – 该认证插件所属的会话对象。
返回值:: 用于验证消息的头，或者失败的 None。请注意，空字典是一个有效的、非失败的响应。
返回类型:: dict

keystoneauth1.identity.v3 包

keystoneauth1.identity.v3 package¶

子模块¶

模块内容¶

keystoneauth1 5.12.1.dev2

页面内容