close icon
Auth0 CLI

Be a Devops Hero! Automate Your Identity Infrastructure with Auth0 CLI and Ansible

Learn how to Automate your identity infrastructure with the help of Auth0 CLI and Ansible.

April 26, 2024

Managing infrastructure can be a complex and time-consuming task, especially as your applications and infrastructure grow and evolve. Add identity management to the mix, and you have a whole new set of challenges to deal with. Automating the configuration and management of your Auth0 resources can help streamline the process and ensure consistency across your environments. Command line tools are an invaluable asset for automation and infrastructure management.

Auth0 CLI is a powerful command-line tool that allows you to manage your Auth0 resources. You can use Auth0 CLI to create and manage Auth0 resources such as clients, users, roles, actions, and more. Auth0 CLI provides a simple and intuitive interface to interact with your Auth0 account from the terminal, making it easy to automate common tasks and streamline your workflow.

Getting Started with Auth0 CLI

Install Auth0 CLI by following the instructions in the official documentation.

Once you have installed the tool, run the below command to connect it to your Auth0 tenant.

auth0 login

When prompted, authenticate as a user since you will use this on your local machine.

If you plan to use the CLI frequently, it might be a good idea to set up command auto completions by following the official guide.

The CLI is now ready to use. Some of the common use cases for the CLI would be;

Run auth0 -h to see a list of all available commands.

Why Use Ansible with Auth0 CLI?

When it comes to automation, there are many tools and strategies available, such as Terraform, Ansible, Puppet, Chef, etc. Choosing the right tool depends on the complexity of your infrastructure, your team's specific needs, and the team's expertise. For those who are command-line superheroes and just want simple orchestration of your scripts, Ansible is the perfect choice, as it is ideal for small to medium projects and one-time tasks.

Ansible is an open-source automation engine that simplifies the deployment and management of applications and infrastructure. Ansible is easy to set up and use. Once set, it gets out of your way so that you can focus on what you do best: writing command line scripts 😸

If you prefer a model-driven approach or if you want features like state management, long-term configuration management, etc., then Terraform is a better choice

Check out our blog post to get started with Auth0 and Terraform.

Get Started with the Auth0 Terraform Provider
Get Started with the Auth0 Terraform Provider
Learn how to get started with the Auth0 Terraform Provider to automate your identity infrastructure.

Ansible may not be ideal for complex Auth0 infrastructure setup and management, but if you are a sysadmin or DevOps engineer, Ansible is great for specific use cases like:

  • Orchestrate One-Time Scripts: If you have a set of one-time scripts that you need to run to configure your Auth0 infrastructure, Ansible is a great choice. You can define your tasks in an Ansible playbook and run them with a single command. These could include setting up Auth0 actions, roles, permissions, etc.
  • Testing: Ansible is great for testing your Auth0 infrastructure configurations. You can define your infrastructure as code in an Ansible playbook and test it in a controlled environment in a reproducible way.
  • User Onboarding: If you need to onboard new users to your Auth0 tenant, Ansible can help automate the process. You can define the tasks required to create new users, assign roles, and configure permissions in an Ansible playbook instead of running individual commands.

By combining Auth0 CLI with Ansible, you can automate the configuration of your infrastructure and ensure consistency across your environment without having to meddle with individual commands.

User Onboarding with Auth0 CLI and Ansible

Install the following tools to get started:

Once the tools are installed, log in to your Auth0 tenant with the necessary permissions using the auth0 login command. Make sure to select the correct tenant from the dropdown when prompted for granting scopes in the browser.

auth0 login --scopes create:authentication_methods

Create a new Ansible playbook

Let us create a playbook to onboard a new user to a tenant.

Create a file, e.g., auth0.yml, and define the following:

- name: Onboard a new user
  hosts: localhost
    - name: tenant
      prompt: 'Set the tenant to use. Leave empty to use default tenant.'
      private: false
    - name: username
      prompt: "What is the user's full name ?"
      private: false
    - name: email
      prompt: "What is the user's email"
      private: false
    - name: default_password
      prompt: 'What is the default password for the user'
    - name: Check mandatory variables are defined
          - username | length > 0
          - email | length > 0
          - default_password | length > 7
    - name: Set tenant
      shell: auth0 tenants use {{ tenant }} --no-input
      when: tenant | length > 0
    - name: Create a user
      shell: auth0 users create --name "{{ username }}" --email {{ email }} --password "{{ default_password }}" --connection-name "Username-Password-Authentication" --json --no-input | jq .user_id
      register: user_output

The playbook does the following:

  • Defines variables like tenant and username.
  • Checks if mandatory variables are set.
  • Sets tenant if the value is passed. Otherwise, it uses the default tenant. You can run the auth0 tenants list to see all available tenants.
  • Creates a new user in the Auth0 tenant.

Let's enable a second-factor authentication for the user. Add the following variable for the phone number to the vars_prompt section.

- name: phone
  prompt: "What is the user's phone number"
  private: false

Add the following task that uses the auth0 api command to add SMS OTP as the second-factor authentication for the user.

- name: Add SMS OTP 2FA for the user
  shell: |
    auth0 api post \
      "users/{{ user_output.stdout[1:-1] }}/authentication-methods" \
      -d '{"type":"phone","name":"sms_otp","phone_number":"{{ phone }}","preferred_authentication_method":"sms"}'
  when: user_output.stdout is defined and phone | length > 0

The task will only be executed if the user is created and a phone number is specified.

Now, let's add commands to assign the user some roles and permissions. Add some new variables for the roles and permissions to the vars_prompt section.

- name: roles
  prompt: 'What are the comma-separated role IDs to assign to the user?'
  private: false
- name: api_id
  prompt: 'What API do you want to assign to the user?'
  private: false
- name: api_permission
  prompt: 'What API permission do you want to assign to the user?'
  default: read:reports
  private: false

Add new tasks to execute the auth0 users roles assign command and add permissions using the auth0 api command.

- name: Add roles for the user
  shell: auth0 users roles assign {{ user_output.stdout }} --roles "{{ roles }}"
  when: user_output.stdout is defined and roles | length > 0
- name: Add permissions for the user
  shell: |
    auth0 api post \
      "users/{{ user_output.stdout[1:-1] }}/permissions" \
      -d '{"permissions":[{"resource_server_identifier":"{{ api_id }}","permission_name":"{{ api_permission }}"}]}'
  when: user_output.stdout is defined

The roles will be assigned only if they are specified during execution, and the permissions will be added only if the user is created.

Run the Ansible playbook

Once you have defined the tasks in your playbook, you can run it using the ansible-playbook command.

ansible-playbook auth0.yml

Ansible will execute the tasks defined in the playbook and automate the onboarding of a new user. You can customize the playbook to include additional tasks like setting up roles, permissions, and other configurations as needed. Look for the console output from Ansible to see the tasks' results. For tasks that use the auth0 api command, you can further customize the flow by extracting the HTTP response code and asserting specific codes to handle errors.


By combining the power of Auth0 CLI and Ansible, you can easily automate the management of your Auth0 resources, saving time and effort in the process. While this is a viable approach for one-time tasks and simple automation, for more complex infrastructure management, you may want to consider using Terraform, which provides more advanced features like state management, long-term configuration management, etc. Auth0 provides native support for Terraform using the Auth0 Terraform Provider.

Happy automating!

Learn More

I hope that you found this article helpful. Here are some additional resources to learn more about Auth0 and DevOps.

You can also sign up for our newsletter to stay updated on everything about identity and security.

If you liked this tutorial, chances are you'll enjoy the others we publish. Please follow @oktadev on Twitter and subscribe to our YouTube channel to get notified when we publish new developer tutorials.

  • Twitter icon
  • LinkedIn icon
  • Faceboook icon