Configurando o Azure Key Vault como um Secretstore

Configure o Azure Key Vault como um segredo usando a autenticação de entidade de serviço ou identidade de carga de trabalho no EKS/AKS.

Você pode configurar o Azure Key Vault como um armazenamento secreto usando um dos seguintes métodos:

• Autenticação da Entidade de Serviço
• Autenticação do Workload Identity

Por padrão, todos os dados confidenciais são definidos em input.json. Você pode separar esses dados em duas partes:

• input.json - contém apenas dados de configuração.
• Azure Key Vault — armazena credenciais com segurança.

Observação:

Você não pode armazenar caminhos de certificados ou credenciais relacionadas a certificados como parte do Secretstore.

Importante:

Todas as credenciais referenciadas em input.json devem existir como segredos no Azure Key Vault antes de você configurar o Secretstore. Se alguma credencial referenciada estiver ausente no Azure Key Vault, a instalação falhará.

Usando a autenticação da entidade de serviço

Para configurar o Azure Key Vault como armazenamento secreto usando a autenticação de entidade de serviço, siga as seguintes etapas:.

1. Para que uipathctl identifique que as credenciais são armazenadas no Azure Key Vault, você deve adicionar a seção Secretstore a input.json , conforme mostrado no exemplo a seguir:

   "secret_store": {
     "enabled": true,
     "provider_configs": [
       {
         "type": "azure",
         "credentials_secret_name": "azure-service-principal-secret",
         "refresh_interval": "5m",
         "name": "azure-secret-store",
         "environment_type": "PublicCloud",
         "azure_kv": {
           "vault_url": "https://eso-azure-kv.vault.azure.net/",
           "tenant_id": "00000000-0000-0000-0000-000000000000"
         }
       }
     ]
   }
   

2. Crie um segredo do Kubernetes que armazene as credenciais da entidade de serviço do Azure, conforme mostrado no exemplo a seguir:

   apiVersion: v1
   kind: Secret
   metadata:
     name: azure-service-principal-secret
   type: Opaque
   stringData:
     clientId: <client-id>
     clientSecret: <client-secret>
   

3. Implante o segredo no namespace uipath usando o seguinte comando:

   kubectl apply -f azure-service-principal-secret -n uipath
   

4. Atualize os valores das credenciais em input.json para fazer referência aos segredos armazenados no Azure Key Vault usando o seguinte formato:

   vault/<vault-name>/<key-stored-in-the-vault>
   

   Onde:

   • vault – palavra-chave estática.
   • vault-name - o valor de secret_store.provider_configs[i].name (por exemplo, azure-secret-store).
   • key-stored-in-the-vault - o nome do segredo conforme armazenado no Azure Key Vault. Antes da alteração, suas credenciais podem ser semelhantes a isto:

   "admin_username": "admin",
   "admin_password": "password",
   

   Após atualizá-los para fazer referência ao Azure Key Vault, eles devem ficar assim:

   "admin_username": "vault/azure-secret-store/admin-username-1234",
   "admin_password": "vault/azure-secret-store/admin-password-1234",
   

   A imagem a seguir mostra os segredos armazenados no Azure Key Vault.

   

O exemplo a seguir exibe uma configuração input.json com credenciais armazenadas no Azure Key Vault.

{
  "admin_password": "vault/azure-secret-store/admin-password-1234",
  "admin_username": "vault/azure-secret-store/admin-username-1234",
  "apps": {
    "enabled": true,
    "external_object_storage": {
      "account_key": "vault/azure-secret-store/apps-external-object-storage-account-key-1234",
      "account_name": "as-storage-account",
      "azure_fqdn_suffix": "core.windows.net",
      "bucket_name": "uipath-as-platform",
      "create_bucket": true,
      "enabled": true,
      "region": "us-east-1",
      "storage_type": "azure",
      "use_instance_profile": true
    }
  },
  "exclude_components": [],
  "external_object_storage": {
    "account_key": "vault/azure-secret-store/external-object-storage-account-key-1234",
    "account_name": "as-storage-account",
    "azure_fqdn_suffix": "core.windows.net",
    "create_bucket": true,
    "enabled": true,
    "region": "us-east-1",
    "storage_type": "azure",
    "use_instance_profile": true
  },
  "fabric": {
    "redis": {
      "hostname": "redis-cache.mycompany.com",
      "password": "vault/azure-secret-store/fabric-redis-password-1234",
      "port": 6380,
      "tls": true
    }
  },
  "fqdn": "automationsuite.mycompany.com",
  "infra": {
    "docker_registry": {}
  },
  "ingress": {
    "gateway_selector": {
      "istio": "ingressgateway"
    },
    "service_annotations": {
      "service.beta.kubernetes.io/azure-load-balancer-internal": "false",
      "service.beta.kubernetes.io/azure-load-balancer-ipv4": "ip-address"
    }
  },
  "install_type": "online",
  "integrationservices": {
    "enabled": true,
    "external_object_storage": {
      "bucket_name": "uipath-as-platform"
    }
  },
  "istioMinProtocolVersion": "TLSV1_3",
  "kubernetes_distribution": "aks",
  "orchestrator": {
    "enabled": true,
    "external_object_storage": {
      "account_key": "vault/azure-secret-store/orchestrator-external-object-storage-account-key-1234",
      "account_name": "os-storage-account",
      "azure_fqdn_suffix": "core.windows.net",
      "bucket_name": "uipath-as-orchestrator",
      "create_bucket": true,
      "enabled": true,
      "region": "us-east-1",
      "storage_type": "azure",
      "use_instance_profile": true
    },
    "sql_connection_str": "vault/azure-secret-store/orchestrator-sql-connection-str-1234",
    "testautomation": {
      "enabled": true
    },
    "updateserver": {
      "enabled": true
    }
  },
  "platform": {
    "enabled": true
  },
  "pod_identity": {
    "aks_managed_identity_client_id": "client-id",
    "enabled": true
  },
  "postgresql_connection_string_template_sqlalchemy_pyodbc": "vault/azure-secret-store/postgresql-connection-string-template-sqlalchemy-pyodbc-1234",
  "profile": "ha",
  "proxy": {
    "enabled": true,
    "http_proxy": "\u003c\u003chttp://\u003cPROXY-SERVER-IP\u003e\u003e:\u003cPROXY-PORT\u003e",
    "https_proxy": "\u003c\u003chttp://\u003cPROXY-SERVER-IP\u003e\u003e:\u003cPROXY-PORT\u003e",
    "no_proxy": "paste list from Configuring the cluster section"
  },
  "registries": {
    "docker": {
      "password": "",
      "pull_secret_name": "registry-credentials",
      "url": "registry.uipath.com",
      "username": ""
    },
    "helm": {
      "password": "",
      "url": "registry.uipath.com",
      "username": ""
    }
  },
  "secret_store": {
    "enabled": true,
    "secret_name": "",
    "provider_configs": [
      {
        "type": "azure",
        "credentials_secret_name": "azure-service-principal-secret",
        "is_default": true,
        "refresh_interval": "5m",
        "name": "azure-secret-store",
        "azure_kv": {
          "vault_url": "https://eso-azure-kv.vault.azure.net/",
          "tenant_id": "00000000-0000-0000-0000-000000000000",
          "managed_identity_id": null
        },
        "aws_kv": {
          "role_arn": null
        },
        "hashicorp_kv": {}
      }
    ]
  },
  "snapshot": {
    "aks_infra_resource_group": "MC_ci-asaks4002399_ci-asaks4002399_eastus",
    "enabled": true,
    "external_object_storage": {
      "account_name": "storaccid2547865",
      "auth_mode": "ServicePrincipal",
      "bucket_name": "uipath-backup",
      "client_id": "1fbd7d95-5f8c-4f70-90a6-fdf20310d10e",
      "client_secret": "vault/azure-secret-store/snapshot-external-object-storage-client-secret-1234",
      "cloud_name": "AzurePublicCloud",
      "resource_group": "ci-asaks4002399",
      "storage_type": "azure",
      "subscription_id": "b65b0225-ce9b-4a79-9dd9-c00071d40d64",
      "tenant_id": "00000000-0000-0000-0000-000000000000"
    }
  },
  "sql_connection_string_template": "vault/azure-secret-store/sql-connection-string-template-1234",
  "sql_connection_string_template_jdbc": "vault/azure-secret-store/sql-connection-string-template-jdbc-1234",
  "sql_connection_string_template_odbc": "vault/azure-secret-store/sql-connection-string-template-odbc-1234",
  "sql_connection_string_template_sqlalchemy_pyodbc": "vault/azure-secret-store/sql-connection-string-template-sqlalchemy-pyodbc-1234",
  "storage_class": "managed-premium",
  "storage_class_single_replica": "azurefile-csi",
  "test_manager": {
    "enabled": true,
    "external_object_storage": {
      "bucket_name": "uipath-as-platform"
    }
  },
  "tolerations": []
}

Configurando o ambiente de nuvem do Azure

O campo environment_type especifica qual ambiente de nuvem do Azure deve ser usado para o acesso ao Cofre de Chaves. Este campo é opcional e o padrão é PublicCloud.

Os seguintes valores são suportados:

Valor	Description
PublicCloud	Nuvem pública do Azure (padrão)
USGovernmentCloud	Nuvem do Azure Governo dos EUA
ChinaCloud	Nuvem Azure China
GermanCloud	Nuvem Azure Alemanha

Observação:

O vault_url deve corresponder ao ambiente de nuvem do Azure. Por exemplo:

• Nuvem pública: https://<vault-name>.vault.azure.net/
• Governo dos EUA: https://<vault-name>.vault.usgovcloudapi.net/
• China: https://<vault-name>.vault.azure.cn/
• Alemanha: https://<vault-name>.vault.microsoftazure.de/

O exemplo a seguir mostra como configurar o campo environment_type em input.json:

"secret_store": {
  "enabled": true,
  "provider_configs": [
    {
      "type": "azure",
      "credentials_secret_name": "azure-service-principal-secret",
      "refresh_interval": "5m",
      "name": "azure-secret-store",
      "environment_type": "USGovernmentCloud",
      "azure_kv": {
        "vault_url": "https://eso-azure-kv.vault.azure.net/",
        "tenant_id": "00000000-0000-0000-0000-000000000000"
      }
    }
  ]
}

Usando a autenticação do Workload Identity

Você pode configurar o Azure Key Vault como um armazenamento secreto usando a autenticação de Identidade da carga de trabalho em vez de uma Entidade de Serviço.

A Identidade do Workload permite que os pods do Kubernetes acessem recursos do Azure sem armazenar credenciais em segredos do Kubernetes.

Dependendo da sua configuração, você pode usar a identidade de carga de trabalho global que se aplica a todos os componentes ou configurar uma identidade de carga de trabalho separada especificamente para o Azure Key Vault, da seguinte forma:

• Usar a identidade da carga de trabalho global

  "pod_identity": {
    "aks_managed_identity_client_id": "managed-identity-id",
    "enabled": true
  },
  "secret_store": {
    "enabled": true,
    "provider_configs": [
      {
        "type": "azure",
        "refresh_interval": "5m",
        "name": "azure-secret-store",
        "azure_kv": {
          "vault_url": "https://eso-azure-kv.vault.azure.net/"
        }
      }
    ]
  }
  

• Use uma identidade de carga de trabalho separada para o Azure Key Vault

  "secret_store": {
    "enabled": true,
    "provider_configs": [
      {
        "type": "azure",
        "refresh_interval": "5m",
        "name": "azure-secret-store",
        "azure_kv": {
          "vault_url": "https://eso-azure-kv.vault.azure.net/",
          "managed_identity_id": "managed-identity-id"
        }
      }
    ]
  }
  

Configurando a identidade gerenciada para o operador de segredos externos

Para habilitar o Operador de segredos externos para acessar o Azure Key Vault usando a identidade de carga de trabalho, siga as seguintes etapas:

1. Perform the steps described in the Workload identity configuration to provide federated credentials to the required service accounts.

2. Além da etapa 3 da configuração da Identidade da carga de trabalho, execute o seguinte comando para criar credenciais federadas para o Operador de segredos externos:

   create_federated_credentials "uipath" "external-secrets"
   

3. Atribua as funções necessárias à identidade gerenciada para que ela possa acessar segredos no Azure Key Vault:

   # Export the following variables with your correct values
   export SUBSCRIPTION_ID="<your-subscription-id>"
   export TARGET_RG="<your-resource-group-name>"
   export VAULT_NAME="<your-key-vault-name>"
   export USER_ASSIGNED_MANAGED_IDENTITY_OBJECT_ID="<your-managed-identity-object-id>"
   
   # Assign Key Vault roles to the managed identity
   az role assignment create --assignee $USER_ASSIGNED_MANAGED_IDENTITY_OBJECT_ID --role "Key Vault Secrets User" --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$TARGET_RG/providers/Microsoft.KeyVault/vaults/$VAULT_NAME"
   az role assignment create --assignee $USER_ASSIGNED_MANAGED_IDENTITY_OBJECT_ID --role "Key Vault Reader" --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$TARGET_RG/providers/Microsoft.KeyVault/vaults/$VAULT_NAME"
   

Configuração do registro privadocompatível com OCI externo

Ao usar um registro privado, se você não quiser configurar as credenciais de registro em input.json, pode fornecê-las como um segredo do Kubernetes, conforme mostrado no exemplo a seguir:

"registries": {
  "docker": {
    "pull_secret_name": "registry-credentials",
    "url": "sfbrdevhelmweacr.azurecr.io"
  }
}

Crie o segredo do Kubernetes que armazena as credenciais de registro, conforme mostrado no exemplo a seguir:

apiVersion: v1
kind: Secret
metadata:
  name: registry-credentials
type: Opaque
data:
  url: base64Encode(sfbrdevhelmweacr.azurecr.io)
  username: base64Encode(<registry-username>)
  password: base64Encode(<registry-password>)

Aplique o segredo no namespace uipath usando o seguinte comando:

kubectl apply -f registry-credentials.yaml -n uipath