Configurar Azure Key Vault como almacén de secretos

Configure Azure Key Vault como almacén de secretos utilizando la autenticación principal de servicio en Automation Suite en OpenShift.

Puedes configurar Azure Key Vault como almacén de secretos utilizando el método de autenticación de la entidad de servicio.

De forma predeterminada, todos los datos confidenciales se definen en input.json. Puedes separar estos datos en dos partes:

• input.json : solo contiene datos de configuración.
• Azure Key Vault: almacena las credenciales de forma segura.

Nota:

No puedes almacenar rutas de certificados o credenciales relacionadas con certificados como parte del almacén de secretos.

Importante:

Todas las credenciales a las que se hace referencia en input.json deben existir como secretos en Azure Key Vault antes de configurar el almacén de secretos. Si falta alguna credencial referenciada de Azure Key Vault, la instalación falla.

Uso de la autenticación principal de servicio

Para configurar Azure Key Vault como almacén de secretos utilizando la autenticación de Service Principal, sigue los siguientes pasos:.

1. Para que uipathctl identifique que las credenciales están almacenadas en Azure Key Vault, debes añadir la sección secretstore a input.json , como se muestra en el siguiente ejemplo:

   "secret_store": {
     "enabled": true,
     "provider_configs": [
       {
         "type": "azure",
         "credentials_secret_name": "azure-service-principal-secret",
         "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"
         }
       }
     ]
   }
   

2. Crea un secreto de Kubernetes que almacene las credenciales de la entidad de servicio de Azure, como se muestra en el siguiente ejemplo:

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

3. Implementa el secreto en el espacio de nombres uipath utilizando el siguiente comando:

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

4. Actualiza los valores de las credenciales en input.json para hacer referencia a los secretos almacenados en Azure Key Vault utilizando el siguiente formato:

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

   Donde:

   • vault : palabra clave estática.
   • vault-name : el valor de secret_store.provider_configs[i].name (por ejemplo, azure-secret-store).
   • key-stored-in-the-vault : el nombre del secreto almacenado en Azure Key Vault. Antes del cambio, tus credenciales podrían tener este aspecto:

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

   Después de actualizarlos para que hagan referencia a Azure Key Vault, deberían tener este aspecto:

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

La siguiente imagen muestra los secretos almacenados en Azure Key Vault.

El siguiente ejemplo muestra una configuración input.json con credenciales almacenadas en Azure Key Vault.

{
  "action_center": {
    "enabled": true
  },
  "admin_password": "vault/azure-secret-store/admin-password-1234",
  "admin_username": "vault/azure-secret-store/admin-username-1234",
  "aicenter": {
    "enabled": true
  },
  "apps": {
    "enabled": true
  },
  "argocd": {
    "application_namespace": "uipath",
    "project": "uipath"
  },
  "automation_hub": {
    "enabled": true
  },
  "automation_ops": {
    "enabled": true
  },
  "dataservice": {
    "enabled": true
  },
  "documentunderstanding": {
    "enabled": true
  },
  "exclude_components": [
    "argocd",
    "monitoring",
    "istio",
    "logging",
    "gatekeeper",
    "network-policies",
    "velero",
    "alerts",
    "cert-manager",
    "dapr",
    "external-secrets"
  ],
  "external_object_storage": {
    "access_key": "vault/azure-secret-store/external-object-storage-access-key-1234",
    "enabled": true,
    "fqdn": "s3storage.mycompany.com",
    "port": 443,
    "region": "us-east-2",
    "secret_key": "vault/azure-secret-store/external-object-storage-secret-key-1234",
    "storage_type": "s3"
  },
  "fabric": {
    "redis": {
      "hostname": "redis.mycompany.com",
      "password": "vault/azure-secret-store/fabric-redis-password-1234",
      "port": 6380,
      "tls": true
    }
  },
  "fqdn": "automationsuite.mycompany.com",
  "ingress": {
    "gateway_selector": {
      "istio": "ingressgateway"
    },
    "ingress_gateway_secret": "istio-ingressgateway-certs",
    "namespace": "\u003cistio-system\u003e"
  },
  "insights": {
    "enabled": true
  },
  "istioMinProtocolVersion": "TLSV1_3",
  "kubernetes_distribution": "openshift",
  "namespace": "uipath",
  "orchestrator": {
    "enabled": true
  },
  "platform": {
    "enabled": true
  },
  "postgresql_connection_string_template_sqlalchemy_pyodbc": "vault/azure-secret-store/postgresql-connection-string-template-sqlalchemy-pyodbc-1234",
  "processmining": {
    "enabled": true
  },
  "profile": "default",
  "registries": {
    "docker": {
      "password": "",
      "pull_secret_name": "registry-credentials",
      "pull_secret_value": "",
      "url": "registry.mycompany.com",
      "username": ""
    },
    "helm": {
      "password": "",
      "url": "registry.mycompany.com",
      "username": ""
    }
  },
  "secret_store": {
    "enabled": true,
    "secret_name": "",
    "provider_configs": [
      {
        "type": "azure",
        "credentials_secret_name": "azure-service-principal-secret",
        "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"
        }
      }
    ]
  },
  "sql": {
    "create_db": true,
    "password": "vault/azure-secret-store/sql-password-1234",
    "port": "1433",
    "server_url": "sql.mycompany.com",
    "username": "vault/azure-secret-store/sql-username-1234"
  },
  "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": "managed-premium",
  "telemetry_optout": true,
  "test_manager": {
    "enabled": true
  }
}

Configurar el entorno de nube de Azure

El campo environment_type especifica qué entorno en la nube de Azure se utilizará para el acceso a Key Vault. Este campo es opcional y el valor predeterminado es PublicCloud.

Se admiten los siguientes valores:

Valor	Descripción
PublicCloud	Nube pública de Azure (predeterminado)
USGovernmentCloud	Nube de Azure US Government
ChinaCloud	Nube de Azure China
GermanCloud	Nube de Azure Alemania

Nota:

El vault_url debe coincidir con el entorno de la nube de Azure. Por ejemplo:

• Nube pública: https://<vault-name>.vault.azure.net/
• Gobierno de EE. UU.: https://<vault-name>.vault.usgovcloudapi.net/
• China: https://<vault-name>.vault.azure.cn/
• Alemania: https://<vault-name>.vault.microsoftazure.de/

El siguiente ejemplo muestra cómo configurar el campo environment_type en 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"
      }
    }
  ]
}

Configurar un registro privado externo compatible con OCI

Al utilizar un registro privado, si no quieres configurar las credenciales de registro en input.json, puedes proporcionarlas como un secreto de Kubernetes, como se muestra en el siguiente ejemplo:

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

Crea el secreto de Kubernetes que almacena las credenciales de registro, como se muestra en el siguiente ejemplo:

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

Aplica el secreto en el espacio de nombres uipath utilizando el siguiente comando:

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