Remplir les conditions préalables de Process Mining

Attention : dapr et cert-manager ne sont plus requis pour Process Mining à partir d’Automation Suite 2024.10.3.

Installation de cert-manager

L'installation de Dapr pour Process Mining nécessite cert-manager.

Pour installer Cert Manager via les opérateurs OpenShift, suivez les instructions détaillées dans Installation de l'opérateur cert-manager pour Red Hat OpenShift.

Pour vous assurer qu'ArgoCD peut créer un certificat à l'aide de cert-manager, vous devez fournir les autorisations nécessaires sur cert-manager à ArgoCD.

L'exemple suivant montre une configuration valide pour le rôle ArgoCD cert-manager :

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: argocd-cert-manager-role
  namespace: <uipath>
rules:
  - apiGroups: ["cert-manager.io"]
    resources: ["certificates", "issuers"]
    verbs: ["get", "create"]

Pour créer la liaison de rôle pour une instance ArgoCD dédiée, exécutez la commande suivante :

oc project <uipath>
oc create rolebinding argocd-cert-manager-binding --role=argocd-cert-manager-role \
  --serviceaccount=<argocd>:argocd-argocd-application-controller

Pour créer la liaison de rôle pour une instance ArgoCD partagée, exécutez la commande suivante :

oc project <uipath>
oc create rolebinding gitops-cert-manager-binding --role=argocd-cert-manager-role \
  --serviceaccount=<openshift-gitops>:openshift-gitops-argocd-application-controller

Désinstallation de Cert Manager

Remarque : vous ne devez pas supprimer cette ressource si Task Mining est activé. Task Mining dépend de Cert Manager.

Prérequis

• OpenShift CLI (oc) installé et configuré.

• Autorisations appropriées pour supprimer des ressources dans les espaces de noms cibles.

Informations requises

Avant de continuer, vous devez recueillir les informations suivantes :

• Espace de noms UiPath dans lequel les ressources du gestionnaire de certificats sont utilisées.

• Qu'il s'agisse d'une instance ArgoCD partagée ou dédiée.

Processus de désinstallation étape par étape

1. Supprimez les liaisons des rôles pour cert-manager :

   • Pour une instance ArgoCD dédiée :

     # Verify if the role binding exists
     oc get rolebinding argocd-cert-manager-binding -n <uipath_namespace>
     
     # If it exists, delete it
     oc delete rolebinding argocd-cert-manager-binding -n <uipath_namespace>

   • Pour l'instance ArgoCD partagée :

     # Verify if the role binding exists
     oc get rolebinding gitops-cert-manager-binding -n <uipath_namespace>
     
     # If it exists, delete it
     oc delete rolebinding gitops-cert-manager-binding -n <uipath_namespace>

2. Supprimez le rôle cert-manager :

   # Check if the role exists
   oc get role argocd-cert-manager-role -n <uipath_namespace>
   
   # If it exists, delete it
   oc delete role argocd-cert-manager-role -n <uipath_namespace>

3. Nettoyez les ressources cert-manager dans l'espace de noms :

   # Delete all certificates
   oc delete certificates.cert-manager.io --all -n <uipath_namespace>
   
   # Delete all issuers
   oc delete issuers.cert-manager.io --all -n <uipath_namespace>
   
   # Delete all clusterissuers if you created any
   oc delete clusterissuers.cert-manager.io --all

4. Désinstallez le gestionnaire de certificats via Operator Hub dans la console OpenShift.

5. Vérifiez les ressources restantes :

   # Check for any remaining cert-manager resources
   oc get all -n <uipath_namespace> | grep cert-manager
   oc get crd | grep cert-manager

Résolution des problèmes

Si certaines ressources ne peuvent pas être supprimées :

• Assurez-vous d'avoir les autorisations nécessaires.

• Vérifiez si les ressources sont utilisées par d'autres applications.

• Pour les ressources bloquées à l’état En fin d’exécution (Terminating) , vous devrez peut-être supprimer les finaliseurs.

Remarques

• Cette procédure de désinstallation suppose que cert-manager a été installé via OpenShift Operator Hub.

• Désinstallez cert-manager uniquement s'il n'est pas utilisé par d'autres applications de votre cluster.

• Si plusieurs applications dépendent de cert-manager, envisagez de supprimer uniquement les ressources spécifiques à UiPath.

• Remplacez <uipath_namespace> par votre espace de noms UiPath réel.

Installation de Dapr

Pour installer Dapr, procédez comme suit :

1. Créez un rôle au niveau du cluster afin qu'ArgoCD puisse gérer les définitions de ressources personnalisées et les webhooks mutating. Pour créer le rôle, procédez comme suit :
   1. Enregistrez la configuration de rôle suivante sous forme de fichier YAML :

      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRole
      metadata:
        annotations:
        name: manage-crds
      rules:
        - apiGroups: ["apiextensions.k8s.io"]
          resources: ["customresourcedefinitions"]
          verbs: ['*']
        - apiGroups: ["admissionregistration.k8s.io"]
          resources: ["mutatingwebhookconfigurations"]
          verbs: ['*']

   2. Appliquez la configuration en exécutant la commande suivante. Assurez-vous de remplacer l'espace réservé <file_name.yaml> par le nom réel du fichier YAML :

      oc apply -f <file_name.yaml>

2. Créez une liaison de rôle au niveau du cluster pour lier le rôle manage-crds au compte de service ArgoCD.
   • Pour créer la liaison de rôle pour une instance ArgoCD dédiée, utilisez la commande suivante :

     oc create clusterrolebinding manage-crds-binding --clusterrole=manage-crds --serviceaccount=<argocd>:argocd-argocd-application-controller

   • Pour créer la liaison de rôle pour une instance ArgoCD partagée, utilisez la commande suivante :

     oc create clusterrolebinding manage-crds-binding --clusterrole=manage-crds --serviceaccount=<openshift-gitops>:openshift-gitops-argocd-application-controller

3. Créez un rôle afin qu'ArgoCD puisse gérer les composants Dapr. Pour créer le rôle, procédez comme suit :
   1. Enregistrez la configuration de rôle suivante sous forme de fichier YAML :

      apiVersion: rbac.authorization.k8s.io/v1
      kind: Role
      metadata:
        name: dapr-creator
        namespace: <uipath>
      rules:
        - apiGroups: ["dapr.io"]
          resources: ["components", "configurations", "resiliencies"]
          verbs: ["create", "delete", "get", "list", "patch", "update", "watch"]

   2. Appliquez la configuration en exécutant la commande suivante. Assurez-vous de remplacer l'espace réservé <file_name.yaml> par le nom réel du fichier YAML :

      oc apply -f <file_name.yaml>

4. Créez une liaison de rôle entre le rôle dapr-creator et le compte de service ArgoCD.
   • Pour créer la liaison de rôle pour une instance ArgoCD dédiée, utilisez la commande suivante :

     oc project <uipath>
     oc create rolebinding dapr-creator-binding --role=dapr-creator --serviceaccount=<argocd>:argocd-argocd-application-controller

   • Pour créer la liaison de rôle pour une instance ArgoCD partagée, utilisez la commande suivante :

     oc project <uipath>
     oc create rolebinding gitops-dapr-creator-binding --role=dapr-creator --serviceaccount=<openshift-gitops>:openshift-gitops-argocd-application-controller

5. Créez une clé secrète d'extraction d'image dans l'espace de noms <uipath> . Pour créer la clé secrète d’extraction de l’image, vous pouvez utiliser votre workflow standard ou suivre les étapes suivantes :

   registry= <registry_url> #provide the registry where the UiPath images are hosted
   username= <user_name> #provide the username which will be used for the authentication
   password= <password> #provide the password which will be used for the authentication
   namespace= <namespace> #namespace where you want to create a secret
   oc create secret docker-registry uipathpullsecret --namespace=${namespace} \
     --docker-server=${registry} --docker-username=${username} \
     --docker-password=${password} --dry-run=client -o yaml \
     | oc apply -f -

6. Créez l'application Argo en utilisant le fichier YAML suivant :

   apiVersion: argoproj.io/v1alpha1
   kind: Application
   metadata:
     name: dapr
     namespace: <argo_namespace>
   spec:
     destination:
       namespace: <uipath_namespace>
       server: https://kubernetes.default.svc
     ignoreDifferences:
     - jsonPointers:
       - /data
       - /stringData
       - /metadata
       kind: Secret
     - group: apiextensions.k8s.io
       jsonPointers:
       - /spec/conversion
       kind: CustomResourceDefinition
     - group: admissionregistration.k8s.io
       jsonPointers:
       - /webhooks
       kind: MutatingWebhookConfiguration
     project: <project_name>
     source:
       chart: helm/dapr
       helm:
         valueFiles:
         - values.yaml
         values: |
           global:
             registry: <target-registry>/daprio
             imagePullSecrets: uipathpullsecret
             mtls:
               enabled: true
             prometheus:
               enabled: false
             logAsJson: true
             actors:
               enabled: false
             ha:
               enabled: false
               replicaCount: 1
             rbac:
               namespaced: true
             seccompProfile: RuntimeDefault
           dapr_dashboard:
             enabled: false
           dapr_operator:
             watchInterval: 1m
             resources:
               requests:
                 cpu: 100m
                 memory: 100Mi
               limits:
                 cpu: "1"
                 memory: 200Mi
             watchNamespace: <uipath_namespace>
             deploymentAnnotations:
               sidecar.istio.io/inject: "false"
           dapr_sidecar_injector:
             allowedServiceAccounts: <uipath_namespace>:default
             resources:
               requests:
                 cpu: 100m
                 memory: 30Mi
               limits:
                 cpu: "1"
                 memory: 100Mi
             sidecarDropALLCapabilities: true
             deploymentAnnotations:
               sidecar.istio.io/inject: "false"
           dapr_sentry:
             resources:
               requests:
                 cpu: 100m
                 memory: 30Mi
               limits:
                 cpu: "1"
                 memory: 100Mi
             deploymentAnnotations:
               sidecar.istio.io/inject: "false"
           dapr_rbac:
             secretReader:
               enabled: false
             createClusterScopedObjects: true
       repoURL: <target-registry>
       targetRevision: <dapr-version>
     syncPolicy:
       automated:
         prune: true
         selfHeal: true
       retry:
         backoff:
           duration: 10s
           factor: 2
           maxDuration: 1m
         limit: 1000
       syncOptions:
       - CreateNamespace=true
       - RespectIgnoreDifferences=true

   Le tableau suivant fournit d'autres informations sur le remplacement des espaces réservés dans le fichier YAML par des valeurs adéquates pour les paramètres respectifs :

   Paramètre	Espace réservé	Description
   namespace	<argo_namespace>	Utilisez <argocd> pour une instance ArgoCD dédiée. Utilisez <openshift-gitops> pour une instance ArgoCD partagée.
   namespace watchNamespace	<uipath_namespace>	Espace de noms pour Automation Suite
   project	<project_name>	Pour une instance ArgoCD dédiée, utilisez default . Pour une instance ArgoCD partagée, utilisez le nom du projet créé pour Automation Suite.
   registry repoURL	<target-registry>	Registre de graphiques Helm
   targetRevision	<dapr-version>	Version du graphique Helm Dapr du fichier versions.json

   Remarque :

   Si vous mettez à jour le nom de domaine complet après l'installation, vous devez supprimer et recréer l'application Dapr en procédant comme suit :

   1. Dans l'interface utilisateur ArgoCD, accédez à Dapr > Supprimer (Delete).

   2. Réinstallez Dapr en suivant toutes les étapes de cette section.

Génération du fichier d'application YAML via le script Bash

Vous pouvez également utiliser le script Bash suivant pour générer le fichier YAML de l'application :

#!/bin/bash

echo "Enter the namespace of argocd applications"
read argocd_namespace

echo "Enter the name of uipath namespace"
read uipath_namespace


if [[ "${argocd_namespace}" == "openshift-gitops" ]]; then
  echo "Enter the argocd project name"
  read project
else
  project="default"
fi

echo "Enter the registry fqdn"
read registry_fqdn

echo "Enter the DAPR helm chart version"
read dapr_version

echo "-------------------- SUMMARY --------------------"
echo "Argocd Application namespace : $argocd_namespace"
echo "Uipath namespace             : $uipath_namespace"
echo "Argocd Project name          : $project"
echo "Helm registry FQDN           : $registry_fqdn"
echo "DAPR Version                 : $dapr_version"

echo "------------- Application yaml file-------------"

echo -n "apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: dapr
  namespace: $argocd_namespace
spec:
  destination:
    namespace: $uipath_namespace
    server: https://kubernetes.default.svc
  ignoreDifferences:
  - jsonPointers:
    - /data
    - /stringData
    - /metadata
    kind: Secret
  - group: apiextensions.k8s.io
    jsonPointers:
    - /spec/conversion
    kind: CustomResourceDefinition
  - group: admissionregistration.k8s.io
    jsonPointers:
    - /webhooks
    kind: MutatingWebhookConfiguration
  project: $project
  source:
    chart: helm/dapr
    helm:
      valueFiles:
      - values.yaml
      values: |
        global:
          registry: $registry_fqdn/daprio
          imagePullSecrets: uipathpullsecret
          mtls:
            enabled: true
          prometheus:
            enabled: false
          logAsJson: true
          actors:
            enabled: false
          ha:
            enabled: false
            replicaCount: 1
          rbac:
            namespaced: true
          seccompProfile: RuntimeDefault
        dapr_dashboard:
          enabled: false
        dapr_operator:
          watchInterval: 1m
          resources:
            requests:
              cpu: 100m
              memory: 100Mi
            limits:
              cpu: "1"
              memory: 200Mi
          watchNamespace: $uipath_namespace
          deploymentAnnotations:
            sidecar.istio.io/inject: "false"
        dapr_sidecar_injector:
          allowedServiceAccounts: $uipath_namespace:default
          resources:
            requests:
              cpu: 100m
              memory: 30Mi
            limits:
              cpu: "1"
              memory: 100Mi
          sidecarDropALLCapabilities: true
          deploymentAnnotations:
            sidecar.istio.io/inject: "false"
        dapr_sentry:
          resources:
            requests:
              cpu: 100m
              memory: 30Mi
            limits:
              cpu: "1"
              memory: 100Mi
          deploymentAnnotations:
            sidecar.istio.io/inject: "false"
        dapr_rbac:
          secretReader:
            enabled: false
          createClusterScopedObjects: true
    repoURL: $registry_fqdn
    targetRevision: $dapr_version
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    retry:
      backoff:
        duration: 10s
        factor: 2
        maxDuration: 1m
      limit: 1000
    syncOptions:
    - CreateNamespace=true
    - RespectIgnoreDifferences=true"

Désinstallation de Dapr

Remarque : vous ne devez pas supprimer cette ressource si Task Mining est activé. Task Mining dépend de Dapr.

Prérequis

• OpenShift CLI (oc) installé et configuré.

• Autorisations appropriées pour supprimer des ressources dans les espaces de noms cibles.

Informations requises

Avant de continuer, vous devez recueillir les informations suivantes :

• Espace de noms UiPath où Dapr est installé.

• Espace de noms ArgoCD (généralement argocd ou openshift-gitops).

• Qu'il s'agisse d'une instance ArgoCD partagée ou dédiée.

Processus de désinstallation étape par étape

1. Supprimez l'application Dapr d'ArgoCD :

   # Verify the application exists first
   oc get application.argoproj.io dapr -n <argocd_namespace>
   
   # If it exists, delete it
   oc delete application.argoproj.io dapr -n <argocd_namespace>

   Attendez que les ressources soient supprimées.

2. Supprimer les ressources personnalisées Dapr :

   # Delete all Dapr components in the UiPath namespace
   oc delete components.dapr.io --all -n <uipath_namespace>
   
   # Delete all Dapr configurations in the UiPath namespace
   oc delete configurations.dapr.io --all -n <uipath_namespace>
   
   # Delete all Dapr resiliencies in the UiPath namespace
   oc delete resiliencies.dapr.io --all -n <uipath_namespace>
   
   # Delete all Dapr subscriptions in the UiPath namespace
   oc delete subscriptions.dapr.io --all -n <uipath_namespace>

3. Supprimer les définitions de ressources personnalisées (CRD) Dapr :

   # Delete Dapr CRDs
   oc delete crd components.dapr.io
   oc delete crd configurations.dapr.io
   oc delete crd resiliencies.dapr.io
   oc delete crd subscriptions.dapr.io

4. Supprimer les configurations du webhook Dapr :

   # Delete the Dapr sidecar injector webhook
   oc delete mutatingwebhookconfigurations dapr-sidecar-injector

5. Supprimer les liaisons de rôles spécifiques à Dapr

   • Pour l'instance ArgoCD partagée :

     # Verify if the role binding exists
     oc get rolebinding gitops-dapr-creator-binding -n <uipath_namespace>
     
     # If it exists, delete it
     oc delete rolebinding gitops-dapr-creator-binding -n <uipath_namespace>
     
     # Check for cert-manager binding (may be used by other applications)
     oc get rolebinding gitops-cert-manager-binding -n <uipath_namespace>
     
     # If it exists and you determine it's safe to delete, run:
     oc delete rolebinding gitops-cert-manager-binding -n <uipath_namespace>

   • Pour une instance ArgoCD dédiée :

     # Verify if the role binding exists
     oc get rolebinding dapr-creator-binding -n <uipath_namespace>
     
     # If it exists, delete it
     oc delete rolebinding dapr-creator-binding -n <uipath_namespace>

6. Supprimer les rôles spécifiques à Dapr :

   # Check if the dapr-creator role exists
   oc get role dapr-creator -n <uipath_namespace>
   
   # If it exists, delete it
   oc delete role dapr-creator -n <uipath_namespace>

7. Nettoyer les ressources Dapr restantes

   • Pods :

     # List all Dapr-related pods
     oc get pods -n <uipath_namespace> | grep dapr
     
     # Delete each Dapr pod
     oc delete pod <pod_name> -n <uipath_namespace>

   • Services :

     # List all Dapr-related services
     oc get svc -n <uipath_namespace> | grep dapr
     
     # Delete each Dapr service
     oc delete svc <service_name> -n <uipath_namespace>

   • Déploiements :

     # List all Dapr-related deployments
     oc get deployments -n <uipath_namespace> | grep dapr
     
     # Delete each Dapr deployment
     oc delete deployment <deployment_name> -n <uipath_namespace>

Vérification

Après avoir terminé toutes les étapes de désinstallation, vérifiez que tous les composants de Dapr ont été supprimés :

# Check for any remaining Dapr resources
oc get pods -n <uipath_namespace> | grep dapr
oc get svc -n <uipath_namespace> | grep dapr
oc get deployments -n <uipath_namespace> | grep dapr
oc get crd | grep dapr

Résolution des problèmes

Si certaines ressources ne peuvent pas être supprimées :

• Assurez-vous d'avoir les autorisations nécessaires.

• Vérifiez si les ressources sont gérées par un autre contrôleur.

• Recherchez toutes les dépendances qui pourraient empêcher la suppression.

Remarques

• Remplacez <uipath_namespace> par votre espace de noms UiPath réel.
• Remplacez <argocd_namespace> par votre espace de noms ArgoCD actuel.

• Soyez prudent lorsque vous supprimez des ressources partagées qui pourraient affecter d'autres applications.

Configuration de Airflow

ArgoCD requiert le rôle suivant lors de l'installation de Airflow :

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: anyuid-role
  namespace: <uipath>
rules:
  - apiGroups: ["security.openshift.io"]
    resources: ["securitycontextconstraints"]
    resourceNames: ["anyuid"]
    verbs: ["use"]

Pour créer la liaison de rôle pour une instance ArgoCD dédiée, exécutez la commande suivante :

oc create rolebinding argocd-anyuid-binding --role=anyuid-role \
  --serviceaccount=<argocd>:argocd-argocd-application-controller -n <uipath>

Vous n'avez pas besoin d'effectuer de configuration supplémentaire pour une instance ArgoCD partagée.