> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Konfiguration

> Konfigurieren Sie ABBYY Vantage Private Cloud: freigegebene Ordner, Datenbankverbindungen, GPU-Unterstützung, Verarbeitungs-Timeouts und SSL/TLS-Zertifikate für den Produktionseinsatz.

<div id="setting-up-a-shared-folder-connection">
  ## Einrichten einer Verbindung zu einem freigegebenen Ordner
</div>

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:

```powershell theme={null}
dism /online /Enable-Feature /FeatureName:ServicesForNFS-ClientOnly
dism /online /Enable-Feature /FeatureName:ClientForNFS-Infrastructure
```

3. Konfigurieren Sie eine Zuordnung von Windows-Benutzern zu Unix-UIDs und -GIDs gemäß den Richtlinien Ihres Unternehmens:

```powershell theme={null}
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
```

4. NFS-Client neu starten:

```powershell theme={null}
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.

<div id="setting-up-a-database-connection">
  ## Einrichten einer Datenbankverbindung
</div>

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.

<Note>
  Stellen Sie vor Beginn sicher, dass das Befehlszeilentool kubectl installiert ist und dass eine Verbindung zum Kubernetes-Cluster hergestellt wurde.
</Note>

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:

```bash theme={null}
kubectl port-forward -n abbyy-infrastructure service/consul-ui 8500:80
```

Navigieren Sie dann zu `http://localhost:8500/ui/dc1/kv/secret/`.

2. Verwenden Sie die Registerkarte **Key/Value**, die sich öffnet, um die richtige Vantage-Umgebung auszuwählen.
3. Wählen Sie entweder das Projekt **platform** oder **vantage** sowie den entsprechenden Dienst, der die Datenbank verwendet (zum Beispiel „mail“).

<img src="https://mintcdn.com/abbyy/-pYAPopytMRFrgKm/images/vantage/private-cloud/misc-p01-005.png?fit=max&auto=format&n=-pYAPopytMRFrgKm&q=85&s=1e0b59d2616def53fa6bc7b903860db8" alt="Liste der Consul-Plattformdienste mit verfügbaren Services" style={{ width:"53%" }} width="642" height="973" data-path="images/vantage/private-cloud/misc-p01-005.png" />

4. Navigieren Sie zum Abschnitt **database**, den jeder Dienst enthält.

<img src="https://mintcdn.com/abbyy/-pYAPopytMRFrgKm/images/vantage/private-cloud/misc-p01-006.png?fit=max&auto=format&n=-pYAPopytMRFrgKm&q=85&s=c6e705ed683a373e87abb35463637d23" alt="Consul-Registerkarte Key/Value mit Auswahl der Vantage-Umgebung" style={{ width:"58%" }} width="636" height="549" data-path="images/vantage/private-cloud/misc-p01-006.png" />

6. Öffnen Sie den Abschnitt **SqlServer**.

<img src="https://mintcdn.com/abbyy/-pYAPopytMRFrgKm/images/vantage/private-cloud/misc-p01-007.png?fit=max&auto=format&n=-pYAPopytMRFrgKm&q=85&s=40cdfc03a52e8ffefb42b7a323be8335" alt="Consul-Datenbankabschnitt mit SqlServer-Konfiguration" style={{ width:"58%" }} width="695" height="539" data-path="images/vantage/private-cloud/misc-p01-007.png" />

6. 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

<img src="https://mintcdn.com/abbyy/-pYAPopytMRFrgKm/images/vantage/private-cloud/misc-p01-008.png?fit=max&auto=format&n=-pYAPopytMRFrgKm&q=85&s=6803280d15df03d2e8cb756b6335ff31" alt="Consul-Editor für den Wert von connectionString" style={{ width:"59%" }} width="877" height="724" data-path="images/vantage/private-cloud/misc-p01-008.png" />

7. Klicken Sie auf **Save**.
8. Starten Sie den geänderten Dienst neu, indem Sie den folgenden Befehl ausführen:

```bash theme={null}
label=mail
kubectl -n abbyy-vantage rollout restart $(kubectl -n abbyy-vantage get deployments -l app.kubernetes.io/component=$label -o name)
```

<Note>
  Wenn sich die Serveradresse ändert, muss dieses Verfahren für jede Datenbank ausgeführt werden.
</Note>

<div id="database-services-reference">
  ### Referenz zu Datenbankdiensten
</div>

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.

<div id="platform-services">
  #### Platform Services
</div>

| Consul-Abschnittsname | Service-Bezeichnung               | Hinweise                                                             |
| --------------------- | --------------------------------- | -------------------------------------------------------------------- |
| api-gateway-registry  | api-gateway-registry              |                                                                      |
| api-registry          | api-registry                      |                                                                      |
| auth-adminapi2        | auth-adminapi2                    |                                                                      |
| auth-identity         | auth-identity                     |                                                                      |
| auth                  | auth-sts-identity, auth-adminapi2 | Diese Datenbank wird von zwei Services verwendet                     |
| blob-storage          | blob-storage                      |                                                                      |
| cron-service          | cron-service                      |                                                                      |
| documentsetstorage    | documentsetstorage                |                                                                      |
| mail                  | mail                              |                                                                      |
| security-audit        | security-audit                    |                                                                      |
| storage               | storage                           | Der Datenbankabschnitt wird im fileMetadata-Datenkatalog gespeichert |
| workflow-facade       | workflow-facade                   |                                                                      |
| workflow-scheduler    | workflow-scheduler                |                                                                      |

<div id="vantage-services">
  #### Vantage-Dienste
</div>

| Consul-Abschnittsname | Dienstbezeichnung |
| --------------------- | ----------------- |
| catalogstorage        | catalogstorage    |
| folderimport          | folderimport      |
| interactive-jobs      | interactive-jobs  |
| mailimport            | mailimport        |
| permissions           | permissions       |
| publicapi             | publicapi         |
| reporting             | reporting         |
| secretstorage         | secretstorage     |
| skill-monitor         | skill-monitor     |
| skillinfo             | skillinfo         |
| subscriptions         | subscriptions     |
| tokenmanagement       | tokenmanagement   |
| transactions          | transactions      |
| workspace             | workspace         |

<div id="setting-up-gpu">
  ## Einrichten der GPU
</div>

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.

<div id="system-requirements-for-gpu">
  ### Systemanforderungen für GPU
</div>

* 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)

<div id="virtual-gpu">
  ### Virtuelle GPU
</div>

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:

```bash theme={null}
apt-get update
apt-get install dkms
dpkg -i nvidia-linux-grid-535_535.54.03_amd64.deb
```

2. 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:

```bash theme={null}
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:

```ini theme={null}
[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:

```bash theme={null}
chmod 600 /root/.ssh/ansible
ansible-playbook -i inventories/k8s -v playbooks/4-Kubernetes-k8s.yml
```

3. Richten Sie vGPU ein, indem Sie das folgende Playbook ausführen:

```bash theme={null}
ansible-playbook -i inventories/k8s -v playbooks/setup-gpu-node.yml
```

<div id="gpu-passthrough">
  ### GPU-Passthrough
</div>

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:

```bash theme={null}
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
```

2. Fügen Sie einen GPU-Knoten (z. B. worker2-12-a40-gpu01) zur Inventory-Datei in der Gruppe `[abbyy_workers]` hinzu:

```ini theme={null}
[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
```

3. Führen Sie das Playbook aus:

```bash theme={null}
ansible-playbook -i inventories/k8s -v playbooks/4-Kubernetes-k8s.yml
```

4. Installieren Sie das Helm-Chart für den GPU Operator:

```bash theme={null}
helm upgrade --install gpu-operator ansible/files/helm/charts/gpu-operator --create-namespace --debug -n gpu-operator
```

5. Fügen Sie dem Knoten einen Taint hinzu:

```bash theme={null}
kubectl taint nodes worker2-12-a40-gpu01 nvidia.com/gpu:NoSchedule
```

<div id="testing-and-deploying-gpu">
  ### Testen und Bereitstellen der GPU
</div>

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:

```bash theme={null}
kubectl apply -f filename
```

2. Erstellen Sie eine YAML-Datei mit folgendem Inhalt und wenden Sie diese an:

```yaml theme={null}
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"
```

3. Prüfen Sie das Pod-Protokoll. Sie sollten eine Antwort sehen, die `Test PASSED` enthält:

```bash theme={null}
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:

```yaml theme={null}
techcore:
  use_gpu_workers: true
  use_nn_extraction_training_workers: true
```

2. Führen Sie einen der folgenden Schritte aus:
   * Wenn Vantage bereits installiert ist, führen Sie das folgende Playbook aus, um GPU-Worker bereitzustellen:

```bash theme={null}
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.

<div id="setting-up-a-manual-review-inactivity-timeout">
  ## Einrichten eines Inaktivitäts-Timeouts für die Manuelle Überprüfung
</div>

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:

```bash theme={null}
kubectl port-forward -n abbyy-infrastructure service/consul-ui 8500:80
```

Then navigate to `http://localhost:8500/ui/dc1/kv/secret/`.

2. Verwenden Sie die Registerkarte **Key/Value**, um die richtige Vantage-Umgebung auszuwählen.
3. Ändern Sie die Werte der folgenden Schlüssel:

| Key                                                                                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `secret/abbyy-vantage/vantage/verification/interactiveJobsOptions/popTimeout`           | Die 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/processingPopTimeout` | Die 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) |

4. Klicken Sie auf **Save**.
5. Starten Sie die Dienste verification und manualverification neu:

```bash theme={null}
kubectl -n abbyy-vantage rollout restart $(kubectl -n abbyy-vantage get deployments -l app.kubernetes.io/component=verification -o name)
```

```bash theme={null}
kubectl -n abbyy-vantage rollout restart $(kubectl -n abbyy-vantage get deployments -l app.kubernetes.io/component=manualverification -o name)
```

<div id="updating-the-ssl-certificate">
  ## Aktualisieren des SSL-Zertifikats
</div>

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

<div id="using-lens">
  ### Lens verwenden
</div>

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

<Note>
  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.
</Note>

3. Klicken Sie auf **Save**.

<div id="using-linux-command-line">
  ### Verwenden der Linux-Befehlszeile
</div>

1. Stellen Sie sicher, dass Sie Zugriff auf den Kubernetes-Cluster haben:

```bash theme={null}
kubectl get nodes
```

2. 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-----
```

3. Führen Sie die folgenden Befehle aus:

```bash theme={null}
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
```

```bash theme={null}
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)
```