deepu-sasidharan

Deepu is a polyglot developer, Java Champion, and OSS aficionado. He mainly works with Java, JS, Rust, and Golang. He co-leads JHipster and created the JDL Studio and KDash. He's a Principal Developer Advocate at Okta. He is also an international speaker and a published author.

Principal Developer Advocate

Deepu K Sasidharan

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

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](https://auth0.github.io/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](https://github.com/auth0/auth0-cli/blob/main/README.md#installation).

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

```shell
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](https://auth0.github.io/auth0-cli/auth0_completion.html).

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

- Managing Auth0 resources like apps, actions, users, and roles.
- Interact with the [Auth0 Management API](https://auth0.com/docs/api/management/v2) via HTTP requests using the [`auth0 api` command](https://auth0.github.io/auth0-cli/auth0_api.html).
- [Stream tenant logs](https://auth0.github.io/auth0-cli/auth0_logs.html).
- Request access tokens for a particular application and test universal login using the [`auth0 test` command](https://auth0.github.io/auth0-cli/auth0_test.html).
- Generate Terraform configurations for your tenant using the [`auth0 terraform` command](https://auth0.github.io/auth0-cli/auth0_terraform_generate.html).
- Download sample apps using the `auth0 quickstarts` command.

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](https://www.ansible.com/) 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.

<include 
    src="LinkCard" 
    title="Get Started with the Auth0 Terraform Provider" 
    link="https://auth0.com/blog/get-started-with-auth0-terraform-provider/" 
    description="Learn how to get started with the Auth0 Terraform Provider to automate your identity infrastructure." 
    img="https://images.ctfassets.net/23aumh6u8s0i/315vJcTNAjaIgQZWxlovOf/a1839ed3bff28c3da8969642252c86a6/terraform-auth0-logo"
/>

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:

- Install Ansible by referring to the [Ansible installation guide](https://docs.ansible.com/ansible/latest/installation_guide/installation_distros.html).
- Install [jq](https://jqlang.github.io/jq/) for JSON parsing.

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.

```shell
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:

```yaml
- name: Onboard a new user
  hosts: localhost
  vars_prompt:
    - 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'
  tasks:
    - name: Check mandatory variables are defined
      assert:
        that:
          - 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.

```yaml
- 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.

```yaml
- 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.

```yaml
- 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?'
  default: https://mydomain.com/api/
  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.

```yaml
- 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.

```bash
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.

## Conclusion

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](https://registry.terraform.io/providers/auth0/auth0/latest/docs).

Happy automating!

## Learn More

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

- [Get Started with the Auth0 Terraform Provider](https://auth0.com/blog/get-started-with-auth0-terraform-provider/)
- [Deploy Secure Spring Boot Microservices on Amazon EKS Using Terraform and Kubernetes](https://auth0.com/blog/terraform-eks-java-microservices/)
- [Shhhh... Kubernetes Secrets Are Not Really Secret!](https://auth0.com/blog/kubernetes-secrets-management/)
- [Auth0 CLI Basics - Lab](https://developer.auth0.com/resources/labs/tools/auth0-cli-basics#introduction)
- [Identity in Spring Boot with Kubernetes, Keycloak, and Auth0](https://auth0.com/blog/identity-in-spring-boot-with-kubernetes-keycloak-and-auth0/)

You can also sign up for our [newsletter](https://a0.to/nl-signup/java) 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](https://twitter.com/oktadev) and [subscribe to our YouTube channel](https://youtube.com/oktadev) to get notified when we publish new developer tutorials.

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

Learn how to get started with the Auth0 Terraform Provider to automate your Auth0 configuration.

When managing infrastructure for any large enough organization, you will need to automate the provisioning and configuration of resources, services, and applications. [Terraform](https://www.terraform.io/) has been the de facto standard for infrastructure as code (IaC) for a while now. Terraform's declarative syntax and cross-platform support make it a great choice for managing infrastructure. Terraform is cloud-agnostic and supports all major cloud providers and on-premise setups. It also supports a lot of other services and applications using [providers](https://registry.terraform.io/browse/providers).

If you use Terraform in your organization and want to configure and manage your Auth0 tenants with Terraform, you are in luck because Auth0 has a Terraform Provider. The [Auth0 Terraform Provider](https://registry.terraform.io/providers/auth0/auth0/latest/docs) allows you to automate the configuration of Auth0 resources like applications, connections, actions, and more. You can also use it to manage users and groups. With the Auth0 Terraform provider, you can automate almost everything you can do via the management UI.

## Overview

So here is what you will learn to do today:

-   Setup the Auth0 Terraform Provider with Auth0 CLI
-   Create a new Auth0 application for OpenID Connect (OIDC) authentication
-   Create roles and users for Auth0
-   Create an action to customize the authentication flow
-   Generate terraform configurations from your existing Auth0 tenant using Auth0 CLI

**Prerequisites:**

-   [Terraform CLI](https://www.terraform.io/downloads) version 1.5+
-   [Auth0 CLI](https://auth0.github.io/auth0-cli/) version 1.1+
-   [jq](https://jqlang.github.io/jq/download/)

## Setup the Auth0 Terraform Provider

Before you can set up the Auth0 Terraform Provider, you need to create a machine-to-machine application in Auth0 so that Terraform can communicate with the Auth0 management API. This can be done using the Auth0 CLI. Install the Auth0 CLI and login to your tenant with the `create:client_grants`.

```bash
auth0 login --scopes create:client_grants
```

> If you don't already have an Auth0 tenant, you can [sign up for a free Auth0 account](https://a0.to/blog_signup) and create a tenant.

Run the following commands to create a machine-to-machine application and extract the client ID and secret from the output.

```bash
# Create a machine-to-machine application on Auth0
export AUTH0_M2M_APP=$(auth0 apps create \
  --name "Auth0 Terraform Provider" \
  --description "Auth0 Terraform Provider M2M" \
  --type m2m \
  --reveal-secrets \
  --json | jq -r '. | {client_id: .client_id, client_secret: .client_secret}')

# Extract the client ID and client secret from the output.
export AUTH0_CLIENT_ID=$(echo $AUTH0_M2M_APP | jq -r '.client_id')
export AUTH0_CLIENT_SECRET=$(echo $AUTH0_M2M_APP | jq -r '.client_secret')
```

> The environment variable names should be exactly as above, as the Terraform provider expects these variables to be set.

The commands above will create the application and set environment variables for the client ID and secret.

This application needs to be authorized to use the Auth0 management API. This can be done using the commands below:

```bash
# Get the ID and IDENTIFIER fields of the Auth0 Management API
export AUTH0_MANAGEMENT_API_ID=$(auth0 apis list --json | jq -r 'map(select(.name == "Auth0 Management API"))[0].id')
export AUTH0_MANAGEMENT_API_IDENTIFIER=$(auth0 apis list --json | jq -r 'map(select(.name == "Auth0 Management API"))[0].identifier')
# Get the SCOPES to be authorized
export AUTH0_MANAGEMENT_API_SCOPES=$(auth0 apis scopes list $AUTH0_MANAGEMENT_API_ID --json | jq -r '.[].value' | jq -ncR '[inputs]')

# Authorize the Auth0 Terraform Provider application to use the Auth0 Management API
auth0 api post "client-grants" --data='{"client_id": "'$AUTH0_CLIENT_ID'", "audience": "'$AUTH0_MANAGEMENT_API_IDENTIFIER'", "scope":'$AUTH0_MANAGEMENT_API_SCOPES'}'
```

> If you don't want to authorize all scopes for the Terraform Provider, you can filter the required scopes from the output of `auth0 apis scopes list` and pass it to the `auth0 api post` command in place of `$AUTH0_MANAGEMENT_API_SCOPES`. Make sure to pass a valid JSON array of strings.

Now, you can set up the Auth0 Terraform Provider. First, make sure you use a specific version of the providers, as different versions might use different attributes and features. Create a `versions.tf` file:

```bash
mkdir terraform
cd terraform
touch versions.tf
```

Add the following to the file:

```hcl
terraform {
  required_version = ">= 1.7.0"

  required_providers {
    auth0 = {
      source  = "auth0/auth0"
      version = "~> 1.1.2" # Refer to docs for latest version
    }
    ## Add other providers here
  }
}
```

Next, you need to define variables and [configure the provider](https://registry.terraform.io/providers/auth0/auth0/latest/docs#schema). Create a `config.tf` file:

```bash
touch config.tf
```

Add the following to the file:

```hcl
variable "auth0_domain" {
  default     = "https://<your_auth0_domain_uri>"
  description = "Auth0 domain"
}

provider "auth0" {
  domain        = var.auth0_domain
  debug         = false
}
```

You can find your Auth0 domain in the [Auth0 dashboard](https://manage.auth0.com/) or by running the `auth0 tenants list` command.

Now, you can initialize the Terraform workspace and test the provider by running the following commands:

```bash
terraform init
```

## Create an Auth0 Application

Let's get into business. Create a Terraform script that creates an Auth0 web application and required customizations. Create a file named `auth0.tf` in the `terraform` folder and add the following content:

```hcl
# Create a new Auth0 application for OIDC authentication
resource "auth0_client" "oidc_client" {
  name                = "MyCoolApp"
  description         = "My Cool App Client Created Through Terraform"
  app_type            = "regular_web"
  callbacks           = ["http://localhost:8080/callback"]
  allowed_logout_urls = ["http://localhost:8080"]
  oidc_conformant     = true

  jwt_configuration {
    alg = "RS256"
  }
}

# Configuring client_secret_post as an authentication method.
resource "auth0_client_credentials" "oidc_client_creds" {
  client_id = auth0_client.oidc_client.id
  authentication_method = "client_secret_post"
}
```

The script above does the following:

-   The `auth0_client` resource definition creates an Auth0 Web application client conforming to the OIDC standard.
-   The `auth0_client_credentials` resource definition configures the client to use the `client_secret_post` authentication method (confidential client using HTTP POST parameters). Other supported methods are:
    -   `none`: Public client without a client secret
    -   `client_secret_basic`: Confidential client using HTTP Basic
    -   `private_key_jwt`: Confidential client using a Private Key JWT

> Refer to the [`auth0_client` schema](https://registry.terraform.io/providers/auth0/auth0/latest/docs/resources/client) and [`auth0_client_credentials` schema](https://registry.terraform.io/providers/auth0/auth0/latest/docs/resources/client_credentials) for all possible configurations.

Next, you can also define some outputs to be captured. Create a `outputs.tf` file:

```bash
touch outputs.tf
```

Add the following to the file:

```hcl
output "auth0_webapp_client_id" {
  description = "Auth0 JavaMicroservices Client ID"
  value       = auth0_client.oidc_client.client_id
}

output "auth0_webapp_client_secret" {
  description = "Auth0 JavaMicroservices Client Secret"
  value       = auth0_client_credentials.oidc_client_creds.client_secret
  sensitive   = true
}
```

Now, you can run the Terraform script to create the Auth0 application. Run the following commands to plan and apply it.

```bash
# see a preview of what will be done
terraform plan
```

Review the plan and make sure everything is correct.

Now you can apply the changes:

```bash
terraform apply
```

You will see the configurations being applied and the output variables printed to the console.

Go to [Auth0 dashboard](https://manage.auth0.com/) and check **Applications** > **Applications**. You should see the application created. You can also find the application using the Auth0 CLI with the `auth0 apps list` command.

If you want to get the client ID and secret from the output, you can run the following command:

```bash
# Client ID
terraform output --json | jq -r '.auth0_webapp_client_id.value'
# Client Secret
terraform output --json | jq -r '.auth0_webapp_client_secret.value'
```

You can update the allowed callback URLs and allowed logout URLs in the Auth0 web application. You can do this by adding the values to the `callbacks` and `allowed_logout_urls` array in the `oidc_client` resource in the `auth0.tf` file like below:

```hcl
resource "auth0_client" "oidc_client" {
  name                = "MyCoolApp"
  description         = "My Cool App Client Created Through Terraform"
  app_type            = "regular_web"
  callbacks           = ["http://localhost:8080/callback", "http://another-domain/callback"]
  allowed_logout_urls = ["http://localhost:8080", "http://another-domain"]
  oidc_conformant     = true

  jwt_configuration {
    alg = "RS256"
  }
}
```

Run `terraform apply -target="auth0_client.oidc_client"` to update the configuration in your Auth0 tenant.

## Create Roles and Users

You can create roles and users using the Auth0 Terraform provider. Let's create some roles and users, and then let's assign the roles to the users.

Add the following content to the `config.tf` file to get a default password while applying the Terraform script:

```hcl
variable "default_password" {
  # Should be a strong password. Example: lkjhasdf$12$12
  description = "Default password for all users"
  sensitive   = true
}
```

Add the following content to the `auth0.tf` file:

```hcl
# Create a role for admin users
resource "auth0_role" "admin" {
  name        = "ROLE_ADMIN"
  description = "Administrator"
}

# Create a role for regular users
resource "auth0_role" "user" {
  name        = "ROLE_USER"
  description = "User"
}

# Create an admin user
resource "auth0_user" "admin_user" {
  connection_name = "Username-Password-Authentication"
  name            = "Jane Doe"
  email           = "jane@test.com"
  email_verified  = true
  password        = var.default_password
}

# Assign roles to the admin user
resource "auth0_user_roles" "admin_user_roles" {
  user_id = auth0_user.admin_user.id
  roles   = [auth0_role.admin.id, auth0_role.user.id]
}

# Create a regular user
resource "auth0_user" "regular_user" {
  connection_name = "Username-Password-Authentication"
  name            = "John Doe"
  email           = "john@test.com"
  email_verified  = false
  password        = var.default_password
}

# Assign roles to the regular user
resource "auth0_user_roles" "regular_user_roles" {
  user_id = auth0_user.regular_user.id
  roles   = [auth0_role.user.id]
}
```

Refer to the [`auth0_role` schema](https://registry.terraform.io/providers/auth0/auth0/latest/docs/resources/role) and [`auth0_user` schema](https://registry.terraform.io/providers/auth0/auth0/latest/docs/resources/user) for all possible configurations. [`auth0_role_permission`](https://registry.terraform.io/providers/auth0/auth0/latest/docs/resources/role_permission) and [`auth0_role_permissions`](https://registry.terraform.io/providers/auth0/auth0/latest/docs/resources/role_permissions) resources can be used to manage permissions for roles.

Run the following commands to plan and apply the changes:

```bash
terraform plan
#  Verify the plan
terraform apply
```

Provide a default password when prompted. You can find the user IDs in the output.

## Create an Action to Customize the Authentication Flow

One of the most powerful features of Auth0 is the ability to customize the authentication flow using [Actions](https://auth0.com/docs/actions). Actions are custom code that runs during the authentication flow. Actions can be used to add custom claims to the ID and access tokens, custom logic to the authentication flow, and more. You can use the Auth0 Terraform provider to create and manage actions.

Let's create an action that adds the roles to the ID and access tokens. Add the following content to the `auth0.tf` file:

```hcl
# Create an action to add the roles to the ID/access token claims.
resource "auth0_action" "roles_action" {
  name    = "add_roles_claim"
  runtime = "node18"
  deploy  = true
  code    = <<-EOT
  /**
   * Handler that will be called during the execution of a PostLogin flow.
   *
   * @param {Event} event - Details about the user and the context in which they are logging in.
   * @param {PostLoginAPI} api - Interface whose methods can be used to change the behavior of the login.
   */
   exports.onExecutePostLogin = async (event, api) => {
     const namespace = 'https://www.cooldomain.com';
     if (event.authorization) {
         api.idToken.setCustomClaim(namespace + '/roles', event.authorization.roles);
         api.accessToken.setCustomClaim(namespace + '/roles', event.authorization.roles);
     }
   };
  EOT

  supported_triggers {
    id      = "post-login"
    version = "v3"
  }
}

# Attach the action to the login flow
resource "auth0_trigger_actions" "login_flow" {
  trigger = "post-login"

  actions {
    id           = auth0_action.roles_action.id
    display_name = auth0_action.roles_action.name
  }
}
```

Refer to the [`auth0_action` schema](https://registry.terraform.io/providers/auth0/auth0/latest/docs/resources/action) for all possible configurations.

Plan and apply the changes:

```bash
terraform plan
#  Verify the plan
terraform apply
```

## Generate Terraform Configurations from Your Existing Auth0 Tenant Using Auth0 CLI

You may already have an existing Auth0 tenant with applications, connections, users, and more. You can use the [Auth0 CLI to generate Terraform configurations](https://registry.terraform.io/providers/auth0/auth0/latest/docs/guides/generate_terraform_config) from your existing Auth0 tenant. Run the following command to generate the Terraform configurations from the above setup:

```bash
export AUTH0_DOMAIN=<your-auth0-domain>
auth0 tf generate --output-dir tmp-auth0-tf
```

This will create the below files in the `tmp-auth0-tf` folder:

-   `auth0_import.tf`: [Terraform configurations to import](https://developer.hashicorp.com/terraform/language/import) the existing resources into the Terraform state.
-   `auth0_main.tf`: Terraform configurations for the Auth0 Terraform Provider. _You may want to update the `required_version` to match the Terraform CLI version you are using._
-   `auth0_generated.tf`: Terraform configurations for the resources in the Auth0 tenant.
-   `terraform`: A specific version of the Terraform binary used for the import. _You can use this binary to run terraform commands if you don't want to update `required_version` in `auth0_main.tf`._
-   `.terraform*`: Terraform state files.

Now, you can import the existing resources into the Terraform state. Run the following commands:

```bash
cd tmp-auth0-tf
terraform apply # You can use your local Terraform CLI if you have updated `required_version` in `auth0_main.tf` else run `./terraform apply`
```

You can verify the generated configurations by running `terraform plan`.

```bash
# You can remove the import file as it's no longer needed.
rm auth0_import.tf
terraform plan
```

The output should be `No changes. Your infrastructure matches the configuration.`

> Note that the `auth0 tf generate` command cannot import sensitive values like secrets and keys.

> Note that this feature is available only from version 1.1+ of the Auth0 CLI, and Terraform import is supported only from Terraform version 1.5+.

## Tear Down the Cluster with Terraform

Once you are done with the tutorial, you can delete all the resources created using Terraform by running the following command:

```bash
terraform destroy
```

## Learn More about Terraform, Auth0, and DevOps

If you want to learn more about Terraform, Auth0 Actions, and DevOps, check out these additional resources.

-   [Deploy Secure Spring Boot Microservices on Amazon EKS Using Terraform and Kubernetes](https://auth0.com/blog/terraform-eks-java-microservices/)
-   [Shhhh... Kubernetes Secrets Are Not Really Secret!](https://auth0.com/blog/kubernetes-secrets-management/)
-   [Auth0 CLI Basics - Lab](https://developer.auth0.com/resources/labs/tools/auth0-cli-basics#introduction)
-   [Assigning a Default Role to Users on Sign-Up with Auth0 Actions](https://auth0.com/blog/assign-default-role-on-sign-up-with-actions/)
-   [Ensure Users Log in from Trusted Networks with Auth0 Actions](https://auth0.com/blog/ensure-users-log-in-trusted-networks-auth0-actions/)

You can also sign up for our [newsletter](https://a0.to/nl-signup/java) to stay updated on everything related to Identity and Security.

If you liked this tutorial, chances are you'll enjoy the others we publish. Please follow [@oktadev on Twitter](https://twitter.com/oktadev) and [subscribe to our YouTube channel](https://youtube.com/oktadev) to get notified when we publish new developer tutorials.

Get Started with the Auth0 Terraform Provider

Learn how to setup secure secrets on Kubernetes using Sealed Secrets, External Secrets Operator, and Secrets Store CSI driver.

Shhhh... Kubernetes Secrets Are Not Really Secret!

auziros:mckenzie-mayer

Customer Identity (CIAM) Product Comms lead, driving collective storytelling across Okta and Auth0. Making technology accessible for everyone.

Customer Identity Product Comms Lead at Okta

McKenzie Mayer

DevOps consultancy will be Auth0’s primary go-to-market channel in the Middle East



**LONDON — May 9, 2019 -** [Auth0](https://auth0.com/), a global leader in Identity-as-a-Service (IDaaS), today announced that [Archinnova](https://www.archinnova.com/), a Dubai-based technology consulting and implementation firm specialising in Agile and DevOps solutions, is the newest member of the [Auth0 Partner Program](https://auth0.com/partners). Archinnova has a highly collaborative approach and understanding of local culture, and will be Auth0's primary go-to-market channel for the Middle East.

Archinnova's DevOps 360 model provides customers with end-to-end support throughout the software development lifecycle, including consultancy, training, tooling, system integration, and support. As a [Solutions Partner](https://auth0.com/partners), Archinnova will offer Auth0's Universal Identity Platform for customers that need to quickly deploy cloud-based identity management as part of their digital transformation projects.

![Auth0 is now part of Artchinnova's DevOps 360 model](https://images.ctfassets.net/23aumh6u8s0i/11ycklVYcNCiJ8xtWyApnI/4cc48cc329f8c4ad4147821c121dbaa6/archinnova-devops360-with-auth0-solutions-partner)

"We chose Auth0 because of their developer focus and ability to handle identity across use cases. They not only fit into our deployment model but also align with our mission to help companies in the region become more nimble and agile," said Diyaa Zebian, executive partner at Archinnova. "Many of our customers build and maintain their own identity solutions, and we can offer Auth0 to help them get to market faster."

"We are thrilled to have Archinnova as our first partner in the Middle East, and look forward to working with them to deliver identity solutions as part of DevOps-driven digital transformation initiatives," said Eric Snyder, Senior Director of Channels and Alliances at Auth0. "The Middle East is becoming hyper-digital, and Archinnova is the best partner to help us address identity needs in the region."

The Middle East is one of the fastest-growing markets for cloud services, with Microsoft and Amazon opening cloud centers in the region this year. According to [IDC](https://www.bloomberg.com/news/articles/2018-10-26/microsoft-and-amazon-see-growth-in-middle-eastern-cloud-services), the Middle East and Africa regions are worth $2.2 billion to cloud vendors, and that's projected to reach $5 billion in 2022. Archinnova's cross-functional team and highly-skilled engineers help customers adapt and compete in a cloud-first world.

To learn more about Archinnova's DevOps360 model and partner ecosystem, please visit: [https://www.archinnova.com/partners](https://www.archinnova.com/partners).

<include src="asides/AboutAuth0" />


"devops"