Konfigurieren von Azure Key Vault als Geheimnisspeicher

Konfigurieren Sie Azure Key Vault als Geheimnisspeicher mithilfe der Dienstprinzipal- oder Workload-Identitäts-Authentifizierung auf EKS/AKS.

Sie können Azure Key Vault mit einer der folgenden Methoden als Secretstore konfigurieren:

• Dienstprinzipalauthentifizierung
• Workload Identity-Authentifizierung

Standardmäßig werden alle vertraulichen Daten in input.json definiert. Sie können diese Daten in zwei Teile aufteilen:

• input.json – enthält nur Konfigurationsdaten.
• Azure Key Vault – Speichert Anmeldeinformationen sicher.

Hinweis:

Sie können Zertifikatspfade oder zertifikatbezogene Anmeldeinformationen nicht als Teil des Secretstore speichern.

Wichtig:

Alle Anmeldeinformationen, auf die in input.json verwiesen wird, müssen als Geheimnisse im Azure Key Vault vorhanden sein, bevor Sie den Geheimnisspeicher konfigurieren. Wenn referenzierte Anmeldeinformationen in Azure Key Vault fehlen, schlägt die Installation fehl.

Verwenden der Dienstprinzipalauthentifizierung

Führen Sie die folgenden Schritte aus, um Azure Key Vault als Geheimnisspeicher mithilfe der Dienstprinzipal-Authentifizierung zu konfigurieren:.

1. Damit uipathctl identifiziert, dass die Anmeldeinformationen im Azure Key Vault gespeichert sind, müssen Sie den Abschnitt Secretstore zu input.json hinzufügen, wie im folgenden Beispiel gezeigt:

   "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. Erstellen Sie ein Kubernetes-Geheimnis, in dem die Anmeldeinformationen des Azure-Dienstprinzipals gespeichert werden, wie im folgenden Beispiel gezeigt:

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

3. Stellen Sie das Geheimnis im Namespace uipath mit dem folgenden Befehl bereit:

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

4. Aktualisieren Sie die Anmeldeinformationswerte in input.json , um auf Geheimnisse zu verweisen, die in Azure Key Vault gespeichert sind, und verwenden Sie das folgende Format:

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

   Wo:

   • vault – statisches Schlüsselwort.
   • vault-name – der Wert von secret_store.provider_configs[i].name (z. B. azure-secret-store).
   • key-stored-in-the-vault – Der Name des Geheimnisses, wie es in Azure Key Vault gespeichert ist. Vor der Änderung sehen Ihre Anmeldeinformationen möglicherweise so aus:

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

   Nachdem sie aktualisiert wurden, um auf Azure Key Vault zu verweisen, sollten sie folgendermaßen aussehen:

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

   Die folgende Abbildung zeigt die in Azure Key Vault gespeicherten Geheimnisse.

   

Im folgenden Beispiel wird eine input.json -Konfiguration mit in Azure Key Vault gespeicherten Anmeldeinformationen angezeigt.

{
  "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": []
}

Konfigurieren der Azure-Cloud-Umgebung

Das Feld environment_type gibt an, welche Azure-Cloud-Umgebung für den Key Vault-Zugriff verwendet werden soll. Dieses Feld ist optional und wird standardmäßig auf PublicCloud festgelegt.

Die folgenden Werte werden unterstützt:

Wert	Beschreibung
PublicCloud	Azure Public Cloud (Standard)
USGovernmentCloud	Azure US Government Cloud
ChinaCloud	Azure China-Cloud
GermanCloud	Azure Deutschland Cloud

Hinweis:

Die vault_url muss mit der Azure-Cloudumgebung übereinstimmen. Zum Beispiel:

• Öffentliche Cloud: https://<vault-name>.vault.azure.net/
• US-Regierung: https://<vault-name>.vault.usgovcloudapi.net/
• China: https://<vault-name>.vault.azure.cn/
• Deutschland: https://<vault-name>.vault.microsoftazure.de/

Das folgende Beispiel zeigt, wie das Feld environment_type in input.json konfiguriert wird:

"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"
      }
    }
  ]
}

Verwenden der Workload Identity-Authentifizierung

Sie können Azure Key Vault als Secretstore mithilfe der Workload-Identitäts-Authentifizierung anstelle eines Dienstprinzipals konfigurieren.

Workload Identity ermöglicht es Kubernetes-Pods, auf Azure-Ressourcen zuzugreifen, ohne Anmeldeinformationen in Kubernetes-Geheimnissen zu speichern.

Je nach Einrichtung können Sie entweder die globale Workload-Identität verwenden, die für alle Komponenten gilt, oder eine separate Workload-Identität speziell für Azure Key Vault wie folgt konfigurieren:

• Verwenden Sie eine globale Workload-Identität

  "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/"
        }
      }
    ]
  }
  

• Verwenden Sie eine separate Workload-Identität für den 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"
        }
      }
    ]
  }
  

Konfigurieren der verwalteten Identität für den Operatorfür externe Geheimnisse

Um dem Operator externer Geheimnisse den Zugriff auf Azure Key Vault mithilfe der Workload-Identität zu ermöglichen, führen Sie die folgenden Schritte aus:

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

2. Führen Sie zusätzlich zu Schritt 3 der Workload-Identitäts-Konfiguration den folgenden Befehl aus, um verbundene Anmeldeinformationen für den External Secrets Operator zu erstellen:

   create_federated_credentials "uipath" "external-secrets"
   

3. Weisen Sie der verwalteten Identität die erforderlichen Rollen zu, damit sie in Azure Key Vault auf Geheimnisse zugreifen kann:

   # 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"
   

Konfigurieren einer externen OCI-konformen privaten Registrierung

Wenn Sie eine private Registrierung verwenden und die Registrierungsanmeldeinformationen nicht in input.json konfigurieren möchten, können Sie sie stattdessen als Kubernetes-Geheimnis angeben, wie im folgenden Beispiel gezeigt:

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

Erstellen Sie das Kubernetes-Geheimnis, in dem die Registrierungsanmeldeinformationen gespeichert werden, wie im folgenden Beispiel gezeigt:

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

Wenden Sie das Geheimnis im Namespace uipath mit dem folgenden Befehl an:

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