Zum Hauptinhalt springen

​
Einrichten einer Verbindung zu einem freigegebenen Ordner

ABBYY Vantage ermöglicht es Ihnen, auf dem Vantage-Server gehostete freigegebene Ordner zum Importieren und Exportieren von Dokumenten und Skills sowie zum Aktualisieren von Datenkatalogen zu verwenden. Bevor Sie freigegebene Ordner (NFS-Share) verwenden können, müssen Sie von einem Client-Computer aus eine Verbindung zu diesen freigegebenen Ordnern herstellen. Führen Sie die folgenden Schritte auf einem Client-Computer mit Windows aus:
  1. Starten Sie Windows PowerShell als Administrator.
  2. Installieren Sie den Windows-NFS-Client:
dism /online /Enable-Feature /FeatureName:ServicesForNFS-ClientOnly
dism /online /Enable-Feature /FeatureName:ClientForNFS-Infrastructure
  1. Konfigurieren Sie eine Zuordnung von Windows-Benutzern zu Unix-UIDs und -GIDs gemäß den Richtlinien Ihres Unternehmens:
New-ItemProperty -Path "HKLM:\Software\Microsoft\ClientForNFS\CurrentVersion\Default" -Name "AnonymousGid" -Value 65532 -PropertyType DWord
New-ItemProperty -Path "HKLM:\Software\Microsoft\ClientForNFS\CurrentVersion\Default" -Name "AnonymousUid" -Value 65532 -PropertyType DWord
  1. NFS-Client neu starten:
nfsadmin client stop
nfsadmin client start
Sobald Sie die oben beschriebenen Schritte abgeschlossen haben, können Sie freigegebene Ordnerpfade in Vantage kopieren und verwenden und im Datei-Explorer öffnen.

​
Einrichten einer Datenbankverbindung

ABBYY Vantage verwendet Datenbanken, die auf externen Servern gehostet werden, und kann funktionsunfähig werden, wenn diese Server ausfallen. Der Systemadministrator kann solche Datenbanken auf einem anderen Server wiederherstellen und mit Consul eine Verbindung zu den neuen Datenbanken einrichten.
Stellen Sie vor Beginn sicher, dass das Befehlszeilentool kubectl installiert ist und dass eine Verbindung zum Kubernetes-Cluster hergestellt wurde.
So richten Sie in den ABBYY Vantage-Einstellungen eine Verbindung zu einer neuen Datenbank ein:
  1. Rufen Sie die Consul-Weboberfläche mit dem folgenden Befehl auf:
kubectl port-forward -n abbyy-infrastructure service/consul-ui 8500:80
Navigieren Sie dann zu http://localhost:8500/ui/dc1/kv/secret/.
  1. Verwenden Sie die Registerkarte Key/Value, die sich öffnet, um die richtige Vantage-Umgebung auszuwählen.
  2. Wählen Sie entweder das Projekt platform oder vantage sowie den entsprechenden Dienst, der die Datenbank verwendet (zum Beispiel „mail“).
Liste der Consul-Plattformdienste mit verfügbaren Services
  1. Navigieren Sie zum Abschnitt database, den jeder Dienst enthält.
Consul-Registerkarte Key/Value mit Auswahl der Vantage-Umgebung
  1. Öffnen Sie den Abschnitt SqlServer.
Consul-Datenbankabschnitt mit SqlServer-Konfiguration
  1. Unter dem Schlüssel connectionString:
    • Ersetzen Sie den alten Wert von Server durch die Adresse des neuen Servers
    • Geben Sie die neue Datenbank im Parameter Database an
    • Geben Sie die Anmeldedaten in den Parametern User Id und Password an
Consul-Editor für den Wert von connectionString
  1. Klicken Sie auf Save.
  2. Starten Sie den geänderten Dienst neu, indem Sie den folgenden Befehl ausführen:
label=mail
kubectl -n abbyy-vantage rollout restart $(kubectl -n abbyy-vantage get deployments -l app.kubernetes.io/component=$label -o name)
Wenn sich die Serveradresse ändert, muss dieses Verfahren für jede Datenbank ausgeführt werden.

​
Referenz zu Datenbankdiensten

Unten finden Sie eine Tabelle, in der alle Dienste aufgelistet sind, die die Datenbank verwenden, sowie ihre Bezeichnung für den Neustart der einzelnen Dienste.

​
Platform Services

Consul-AbschnittsnameService-BezeichnungHinweise
api-gateway-registryapi-gateway-registry
api-registryapi-registry
auth-adminapi2auth-adminapi2
auth-identityauth-identity
authauth-sts-identity, auth-adminapi2Diese Datenbank wird von zwei Services verwendet
blob-storageblob-storage
cron-servicecron-service
documentsetstoragedocumentsetstorage
mailmail
security-auditsecurity-audit
storagestorageDer Datenbankabschnitt wird im fileMetadata-Datenkatalog gespeichert
workflow-facadeworkflow-facade
workflow-schedulerworkflow-scheduler

​
Vantage-Dienste

Consul-AbschnittsnameDienstbezeichnung
catalogstoragecatalogstorage
folderimportfolderimport
interactive-jobsinteractive-jobs
mailimportmailimport
permissionspermissions
publicapipublicapi
reportingreporting
secretstoragesecretstorage
skill-monitorskill-monitor
skillinfoskillinfo
subscriptionssubscriptions
tokenmanagementtokenmanagement
transactionstransactions
workspaceworkspace

​
Einrichten der GPU

Vantage ermöglicht es Ihnen, eine GPU zu verwenden, um Skills mithilfe der Deep-Learning-Aktivität für die Datenextraktion aus halbstrukturierten Dokumenten zu trainieren.

​
Systemanforderungen für GPU

  • Mindestens 12 GB virtueller GPU-Speicher
  • 1 CPU und 4 GB RAM für jede virtuelle GPU auf dem Host (z. B. muss eine VM mit einer einzelnen virtuellen GPU mit 12 GB mindestens 2 CPUs und 8 GB RAM haben)

​
Virtuelle GPU

Sie können eine virtuelle GPU (vGPU) verwenden, um eine physische GPU auf mehrere virtuelle Maschinen aufzuteilen und so die Vantage-Ressourcen effizienter zu nutzen. So konfigurieren Sie vGPU:
  1. Kopieren Sie das NVIDIA GRID-Treiberpaket aus dem NVIDIA Application Hub auf eine virtuelle Maschine mit einer GPU und führen Sie die folgenden Befehle aus:
apt-get update
apt-get install dkms
dpkg -i nvidia-linux-grid-535_535.54.03_amd64.deb
  1. Installieren Sie den nVidia GPU Operator im Kubernetes-Cluster: a. Legen Sie die Lizenz-Token-Datei (im nVidia Application Hub generiert) im Ordner $PWD/gpu/ ab, bevor Sie den Vantage-Installer-Container starten. b. Fügen Sie den Parameter -v $PWD/gpu:/ansible/files/gpu:ro zu dem Befehl hinzu, mit dem der Vantage-Installer-Container gestartet wird: 
docker run -it \
-v $PWD/kube:/root/.kube \
-v $PWD/ssh/ansible:/root/.ssh/ansible \
-v "//var/run/docker.sock:/var/run/docker.sock" \
-v $PWD/inventory:/ansible/inventories/k8s/inventory \
-v $PWD/env_specific.yml:/ansible/inventories/k8s/group_vars/all/env_specific.yml \
-v $PWD/ssl:/ansible/files/ssl:ro \
-v $PWD/gpu:/ansible/files/gpu:ro \
--privileged \
registry.local/vantage/vantage-k8s:2.7.1
c. Fügen Sie einen GPU-Knoten zur Inventardatei in der Gruppe [abbyy_workers] hinzu. Der Name der virtuellen Maschine mit der GPU muss „gpu“ enthalten: 
[abbyy_workers]
worker16-48-w01 ansible_host=10.10.10.27
worker16-48-w02 ansible_host=10.10.10.21
worker16-48-w03 ansible_host=10.10.10.20
worker2-12-a40-gpu01 ansible_host=10.10.10.60
d. Fügen Sie dem Cluster einen Knoten hinzu, indem Sie das folgende Playbook ausführen: 
chmod 600 /root/.ssh/ansible
ansible-playbook -i inventories/k8s -v playbooks/4-Kubernetes-k8s.yml
  1. Richten Sie vGPU ein, indem Sie das folgende Playbook ausführen:
ansible-playbook -i inventories/k8s -v playbooks/setup-gpu-node.yml

​
GPU-Passthrough

Sie können GPU-Passthrough einrichten, damit eine virtuelle Maschine direkten Zugriff auf Ihre GPU erhält. So richten Sie GPU-Passthrough ein:
  1. Führen Sie den Vantage-Installer-Container aus:
docker run -it \
-v $PWD/kube:/root/.kube \
-v $PWD/ssh/ansible:/root/.ssh/ansible \
-v "//var/run/docker.sock:/var/run/docker.sock" \
-v $PWD/inventory:/ansible/inventories/k8s/inventory \
-v $PWD/env_specific.yml:/ansible/inventories/k8s/group_vars/all/env_specific.yml \
-v $PWD/ssl:/ansible/files/ssl:ro \
--privileged \
registry.local/vantage/vantage-k8s:2.7.1
  1. Fügen Sie einen GPU-Knoten (z. B. worker2-12-a40-gpu01) zur Inventory-Datei in der Gruppe [abbyy_workers] hinzu:
[abbyy_workers]
worker16-48-w01 ansible_host=10.10.10.27
worker16-48-w02 ansible_host=10.10.10.21
worker16-48-w03 ansible_host=10.10.10.20
worker2-12-a40-gpu01 ansible_host=10.10.10.60
  1. Führen Sie das Playbook aus:
ansible-playbook -i inventories/k8s -v playbooks/4-Kubernetes-k8s.yml
  1. Installieren Sie das Helm-Chart für den GPU Operator:
helm upgrade --install gpu-operator ansible/files/helm/charts/gpu-operator --create-namespace --debug -n gpu-operator
  1. Fügen Sie dem Knoten einen Taint hinzu:
kubectl taint nodes worker2-12-a40-gpu01 nvidia.com/gpu:NoSchedule

​
Testen und Bereitstellen der GPU

Sowohl für vGPU- als auch für GPU-Passthrough-Modi gehen Sie zum Testen einer GPU-Operator-Installation wie folgt vor:
  1. Führen Sie diesen Befehl aus:
kubectl apply -f filename
  1. Erstellen Sie eine YAML-Datei mit folgendem Inhalt und wenden Sie diese an:
apiVersion: v1
kind: Pod
metadata:
  name: gpu-pod
  namespace: gpu-operator
spec:
  restartPolicy: Never
  containers:
    - name: cuda-container
      image: nvcr.io/nvidia/k8s/cuda-sample:vectoradd-cuda10.2
      resources:
        limits:
          nvidia.com/gpu: 1 # 1 GPU anfordern
  tolerations:
    - key: nvidia.com/gpu
      operator: Exists
      effect: NoSchedule
    - key: k8s.abbyy.com/techcore
      effect: NoSchedule
      value: "true"
  1. Prüfen Sie das Pod-Protokoll. Sie sollten eine Antwort sehen, die Test PASSED enthält:
kubectl -n gpu-operator logs gpu-pod
Erwartete Ausgabe: 
[Vector addition of 50000 elements]
Copy input data from the host memory to the CUDA device
CUDA kernel launch with 196 blocks of 256 threads
Copy output data from the CUDA device to the host memory
Test PASSED
Done
So stellen Sie den GPU-Worker bereit:
  1. Fügen Sie die folgenden Parameter zur Datei env_specific.yml hinzu:
techcore:
  use_gpu_workers: true
  use_nn_extraction_training_workers: true
  1. Führen Sie einen der folgenden Schritte aus:
    • Wenn Vantage bereits installiert ist, führen Sie das folgende Playbook aus, um GPU-Worker bereitzustellen:
ansible-playbook -i inventories/k8s -v playbooks/11-DeployWorkers-k8s.yml
  • Wenn Vantage noch nicht installiert wurde, werden GPU-Worker während der Installation mit bereitgestellt.

​
Einrichten eines Inaktivitäts-Timeouts für die Manuelle Überprüfung

In der Manuellen Überprüfung wird ein Timeout ausgelöst, wenn der Operator in Bezug auf eine offene Aufgabe 15 Minuten lang keine Aktionen durchführt. Der Systemadministrator kann die für ein Timeout erforderliche Inaktivitätsdauer über Consul ändern. So konfigurieren Sie das Timeout:
  1. Greifen Sie auf die Consul-Weboberfläche zu, indem Sie Folgendes ausführen:
kubectl port-forward -n abbyy-infrastructure service/consul-ui 8500:80
Then navigate to http://localhost:8500/ui/dc1/kv/secret/.
  1. Verwenden Sie die Registerkarte Key/Value, um die richtige Vantage-Umgebung auszuwählen.
  2. Ändern Sie die Werte der folgenden Schlüssel:
KeyDescription
secret/abbyy-vantage/vantage/verification/interactiveJobsOptions/popTimeoutDie Mindestdauer der Inaktivität eines Benutzers, bevor eine Aufgabe in die Warteschlange für interaktive Aufgaben zurückgegeben wird. Jede interaktive Aktion (Mausbewegung, Tastatureingabe, Patchverarbeitung usw.) setzt den Countdown zurück. Standardwert: 00:15:00 (15 Minuten)
secret/abbyy-vantage/vantage/verification/interactiveJobsOptions/processingPopTimeoutDie Mindestdauer der Benutzerinaktivität, nach der die Aufgabe wieder in die Warteschlange gestellt wird, wenn lang andauernde Vorgänge ausgeführt werden (Anwenden eines Skills, Blättern durch Seiten usw.). Wenn ein lang andauernder Vorgang startet, wird dieser Wert auf die maximal zulässige Inaktivitätsdauer gesetzt. Wenn der Vorgang abgeschlossen ist, wird die Inaktivitätsdauer auf den popTimeout-Wert zurückgesetzt. Standardwert: 1.00:00:00 (24 Stunden)
  1. Klicken Sie auf Save.
  2. Starten Sie die Dienste verification und manualverification neu:
kubectl -n abbyy-vantage rollout restart $(kubectl -n abbyy-vantage get deployments -l app.kubernetes.io/component=verification -o name)

kubectl -n abbyy-vantage rollout restart $(kubectl -n abbyy-vantage get deployments -l app.kubernetes.io/component=manualverification -o name)

​
Aktualisieren des SSL-Zertifikats

Wenn das SSL-Zertifikat abläuft, müssen Sie es durch ein neues ersetzen.

​
Lens verwenden

  1. Gehen Sie zu Config > Secrets und suchen Sie alle Secrets mit der Bezeichnung platform-wildcard.
  2. Suchen Sie für jedes Secret den Abschnitt Data, klicken Sie auf das Show-Symbol und aktualisieren Sie die Werte:
    • Geben Sie den Wert des neuen Zertifikats in das Feld tls.crt ein
    • Geben Sie den Wert des zugehörigen Schlüssels in das Feld tls.key ein
Das Zertifikat und der Schlüssel müssen PEM-Dateien mit in Base64-ASCII codiertem Inhalt (PKCS#8) sein. Für das Zertifikat sollten sie mit -----BEGIN CERTIFICATE----- und für den Schlüssel mit -----BEGIN PRIVATE KEY----- beginnen.
  1. Klicken Sie auf Save.

​
Verwenden der Linux-Befehlszeile

  1. Stellen Sie sicher, dass Sie Zugriff auf den Kubernetes-Cluster haben:
kubectl get nodes
  1. Platzieren Sie das Zertifikat und den Schlüssel im PEM-Format in das aktuelle Verzeichnis: cert.pem, key.pem.
Konvertieren Sie Ihre CRT-Datei bei Bedarf in das PEM-Format: 
-----BEGIN CERTIFICATE-----
[your certificate]
-----END CERTIFICATE-----

-----BEGIN PRIVATE KEY-----
[your key]
-----END PRIVATE KEY-----
  1. Führen Sie die folgenden Befehle aus:
for i in `kubectl get secret --field-selector metadata.name=platform-wildcard -o custom-columns=:metadata.namespace -A --no-headers 2>/dev/null`; do kubectl patch secret platform-wildcard -p "{\"data\":{\"tls.key\":\"$(base64 < "./key.pem" | tr -d '\n')\", \"tls.crt\":\"$(base64 < "./cert.pem" | tr -d '\n')\"}}" -n $i; done

kubectl rollout restart deployment -n abbyy-infrastructure $(kubectl get deployment -n abbyy-infrastructure -o custom-columns=NAME:metadata.name --no-headers 2>/dev/null | grep ingress-nginx-controller)