.. role:: raw-html-m2r(raw)
:format: html
Azure Identity client library for Python
========================================
Azure Identity authenticating with Azure Active Directory for Azure SDK
libraries. It provides credentials Azure SDK clients can use to authenticate
their requests.
This library currently supports:
* `Service principal authentication `_
* `Managed identity authentication `_
*
User authentication
`Source code `_
| `Package (PyPI) `_
| `API reference documentation `_
| `Azure Active Directory documentation `_
Getting started
===============
Prerequisites
-------------
* an `Azure subscription `_
* Python 2.7 or 3.5.3+
Install the package
-------------------
Install Azure Identity with pip:
.. code-block:: sh
pip install azure-identity
Creating a Service Principal with the Azure CLI
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This library doesn't require a service principal, but Azure applications
commonly use them for authentication. If you need to create one, you can use
this `Azure CLI `_ snippet. Before using
it, replace "http://my-application" with a more appropriate name for your
service principal.
Create a service principal:
.. code-block:: sh
az ad sp create-for-rbac --name http://my-application --skip-assignment
Example output:
.. code-block:: json
{
"appId": "generated-app-id",
"displayName": "app-name",
"name": "http://my-application",
"password": "random-password",
"tenant": "tenant-id"
}
Azure Identity can authenticate as this service principal using its tenant id
("tenant" above), client id ("appId" above), and client secret ("password" above).
Key concepts
============
Credentials
-----------
A credential is a class which contains or can obtain the data needed for a
service client to authenticate requests. Service clients across the Azure SDK
accept credentials as constructor parameters, as described in their
documentation. The `next steps <#client-library-support>`_ section below contains
a partial list of client libraries accepting Azure Identity credentials.
Credential classes are found in the ``azure.identity`` namespace. They differ
in the types of identities they can authenticate as, and in their configuration:
.. list-table::
:header-rows: 1
* - credential class
- identity
- configuration
* - :raw-html-m2r:`DefaultAzureCredential`
- service principal, managed identity, user
- none for managed identity, :raw-html-m2r:`environment variables` for service principal or user authentication
* - `ManagedIdentityCredential `_
- managed identity
- none
* - `EnvironmentCredential `_
- service principal, user
- :raw-html-m2r:`environment variables`
* - `ClientSecretCredential `_
- service principal
- constructor parameters
* - `CertificateCredential `_
- service principal
- constructor parameters
* - `DeviceCodeCredential `_
- user
- constructor parameters
* - `InteractiveBrowserCredential `_
- user
- constructor parameters
* - `UsernamePasswordCredential `_
- user
- constructor parameters
Credentials can be chained together and tried in turn until one succeeds; see
:raw-html-m2r:`chaining credentials` for details.
Service principal and managed identity credentials have async equivalents in
the `azure.identity.aio `_ namespace, supported on Python 3.5.3+.
See the :raw-html-m2r:`async credentials` example for
details. Async user credentials will be part of a future release.
DefaultAzureCredential
----------------------
`DefaultAzureCredential `_ is appropriate for most
applications intended to run in Azure. It can authenticate as a service
principal, managed identity, or user, and can be configured for local
development and production environments without code changes.
To authenticate as a service principal, provide configuration in
:raw-html-m2r:`environment variables` as
described in the next section.
Authenticating as a managed identity requires no configuration but is only
possible in a supported hosting environment. See Azure Active Directory's
`managed identity documentation `_
for more information.
Single sign-on
~~~~~~~~~~~~~~
During local development on Windows, `DefaultAzureCredential `_
can authenticate using a single sign-on shared with Microsoft applications, for
example Visual Studio 2019. This may require additional configuration when
multiple identities have signed in. In that case, set the environment variables
``AZURE_USERNAME`` (typically an email address) and ``AZURE_TENANT_ID`` to select
the desired identity. Either, or both, may be set.
Environment variables
---------------------
`DefaultAzureCredential `_ and
`EnvironmentCredential `_ can be configured with
environment variables. Each type of authentication requires values for specific
variables:
Service principal with secret
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
..
.. list-table::
:header-rows: 1
* - variable name
- value
* - ``AZURE_CLIENT_ID``
- id of an Azure Active Directory application
* - ``AZURE_TENANT_ID``
- id of the application's Azure Active Directory tenant
* - ``AZURE_CLIENT_SECRET``
- one of the application's client secrets
Service principal with certificate
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
..
.. list-table::
:header-rows: 1
* - variable name
- value
* - ``AZURE_CLIENT_ID``
- id of an Azure Active Directory application
* - ``AZURE_TENANT_ID``
- id of the application's Azure Active Directory tenant
* - ``AZURE_CLIENT_CERTIFICATE_PATH``
- path to a PEM-encoded certificate file including private key (without password protection)
Username and password
~~~~~~~~~~~~~~~~~~~~~
..
.. list-table::
:header-rows: 1
* - variable name
- value
* - ``AZURE_CLIENT_ID``
- id of an Azure Active Directory application
* - ``AZURE_USERNAME``
- a username (usually an email address)
* - ``AZURE_PASSWORD``
- that user's password
Note: username/password authentication is not supported by the async API
(\ `azure.identity.aio `_\ )
Configuration is attempted in the above order. For example, if values for a
client secret and certificate are both present, the client secret will be used.
Examples
========
Authenticating with ``DefaultAzureCredential``
--------------------------------------------------
This example demonstrates authenticating the ``BlobServiceClient`` from the
`azure-storage-blob `_ library using
:raw-html-m2r:`DefaultAzureCredential`.
.. code-block:: py
from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient
# This credential first checks environment variables for configuration as described above.
# If environment configuration is incomplete, it will try managed identity.
credential = DefaultAzureCredential()
client = BlobServiceClient(account_url, credential=credential)
Authenticating a service principal with a client secret:
--------------------------------------------------------
This example demonstrates authenticating the ``KeyClient`` from the
`azure-keyvault-keys `_ library using
`ClientSecretCredential `_.
.. code-block:: py
from azure.identity import ClientSecretCredential
from azure.keyvault.keys import KeyClient
credential = ClientSecretCredential(tenant_id, client_id, client_secret)
client = KeyClient("https://my-vault.vault.azure.net", credential)
Authenticating a service principal with a certificate:
------------------------------------------------------
This example demonstrates authenticating the ``SecretClient`` from the
`azure-keyvault-secrets `_ library using
`CertificateCredential `_.
.. code-block:: py
from azure.identity import CertificateCredential
from azure.keyvault.secrets import SecretClient
# requires a PEM-encoded certificate with private key
cert_path = "/app/certs/certificate.pem"
credential = CertificateCredential(tenant_id, client_id, cert_path)
# if the private key is password protected, provide a 'password' keyword argument
credential = CertificateCredential(tenant_id, client_id, cert_path, password="cert-password")
client = SecretClient("https://my-vault.vault.azure.net", credential)
Chaining credentials
--------------------
`ChainedTokenCredential `_ links multiple credential instances
to be tried sequentially when authenticating. It will try each chained
credential in turn until one provides a token or fails to authenticate due to
an error.
The following example demonstrates creating a credential which will attempt to
authenticate using managed identity, and fall back to a service principal when
managed identity is unavailable. This example uses the ``EventHubClient`` from
the `azure-eventhub `_ client library.
.. code-block:: py
from azure.eventhub import EventHubClient
from azure.identity import ChainedTokenCredential, ClientSecretCredential, ManagedIdentityCredential
managed_identity = ManagedIdentityCredential()
service_principal = ClientSecretCredential(tenant_id, client_id, client_secret)
# when an access token is needed, the chain will try each credential in order,
# stopping when one provides a token or fails to authenticate due to an error
credential_chain = ChainedTokenCredential(managed_identity, service_principal)
# the ChainedTokenCredential can be used anywhere a credential is required
client = EventHubClient(host, event_hub_path, credential_chain)
Async credentials:
------------------
This library includes an async API supported on Python 3.5+. To use the async
credentials in `azure.identity.aio `_\ , you must first install an
async transport, such as `aiohttp `_. See
`azure-core documentation `_
for more information.
Async credentials should be closed when they're no longer needed. Each async
credential is an async context manager and defines an async ``close`` method. For
example:
.. code-block:: py
from azure.identity.aio import DefaultAzureCredential
# call close when the credential is no longer needed
credential = DefaultAzureCredential()
...
await credential.close()
# alternatively, use the credential as an async context manager
credential = DefaultAzureCredential()
async with credential:
...
This example demonstrates authenticating the asynchronous ``SecretClient`` from
`azure-keyvault-secrets `_ with an asynchronous
credential.
.. code-block:: py
# most credentials have async equivalents supported on Python 3.5.3+
from azure.identity.aio import DefaultAzureCredential
from azure.keyvault.secrets.aio import SecretClient
# async credentials have the same API and configuration as their synchronous
# counterparts, and are used with (async) Azure SDK clients in the same way
default_credential = DefaultAzureCredential()
client = SecretClient("https://my-vault.vault.azure.net", default_credential)
Troubleshooting
===============
General
-------
Credentials raise ``CredentialUnavailableError`` when they're unable to attempt
authentication because they lack required data or state. For example,
`EnvironmentCredential `_ will raise this exception when
:raw-html-m2r:`its configuration` is incomplete.
Credentials raise ``azure.core.exceptions.ClientAuthenticationError`` when they fail
to authenticate. ``ClientAuthenticationError`` has a ``message`` attribute which
describes why authentication failed. When raised by
`DefaultAzureCredential <#defaultazurecredential>`_ or ``ChainedTokenCredential``\ ,
the message collects error messages from each credential in the chain.
For more details on handling Azure Active Directory errors please refer to the
Azure Active Directory
`error code documentation `_.
Next steps
==========
Client library support
----------------------
This is an incomplete list of client libraries accepting Azure Identity
credentials. You can learn more about these libraries, and find additional
documentation of them, at the links below.
* `azure-appconfiguration `_
* `azure-eventhub `_
* `azure-keyvault-certificates `_
* `azure-keyvault-keys `_
* `azure-keyvault-secrets `_
* `azure-storage-blob `_
* `azure-storage-queue `_
Provide Feedback
----------------
If you encounter bugs or have suggestions, please
`open an issue `_.
Contributing
============
This project welcomes contributions and suggestions. Most contributions require
you to agree to a Contributor License Agreement (CLA) declaring that you have
the right to, and actually do, grant us the rights to use your contribution.
For details, visit `https://cla.microsoft.com `_.
When you submit a pull request, a CLA-bot will automatically determine whether
you need to provide a CLA and decorate the PR appropriately (e.g., label,
comment). Simply follow the instructions provided by the bot. You will only
need to do this once across all repos using our CLA.
This project has adopted the
`Microsoft Open Source Code of Conduct `_.
For more information, see the
`Code of Conduct FAQ `_
or contact `opencode@microsoft.com `_ with any
additional questions or comments.
.. image:: https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-python%2Fsdk%2Fidentity%2Fazure-identity%2FREADME.png
:target: https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-python%2Fsdk%2Fidentity%2Fazure-identity%2FREADME.png
:alt: Impressions
Indices and tables
------------------
* :ref:`genindex`
* :ref:`modindex`
* :ref:`search`
.. toctree::
:maxdepth: 5
:glob:
:caption: Developer Documentation
azure.identity.rst