AWS Der Mainframe Modernization Service (Managed Runtime Environment Experience) steht Neukunden nicht mehr zur Verfügung. Funktionen, die dem AWS Mainframe Modernization Service (Managed Runtime Environment-Erfahrung) ähneln, finden Sie unter AWS Mainframe Modernization Service (Self-Managed Experience). Bestandskunden können den Service weiterhin wie gewohnt nutzen. Weitere Informationen finden Sie unter Änderung der Verfügbarkeit von [AWS Mainframe Modernization](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html).

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# AWS Transformation für Mainframe-Runtime-Geheimnisse
<a name="ba-runtime-config-app-secrets"></a>

Einige der Ressourcenkonfigurationen, die Anmeldeinformationen enthalten, können mithilfe von AWS Geheimnissen weiter gesichert werden. Die Idee ist, kritische Daten AWS geheim zu speichern und in der YAML-Konfiguration einen Verweis auf das Geheimnis zu haben, sodass der geheime Inhalt beim Start von Apache Tomcat im Handumdrehen abgerufen wird.

## Geheimnisse für Aurora
<a name="ba-runtime-config-app-secrets-aur"></a>

Die Aurora-Datenbankkonfiguration (für JICSBlusam, Kundendatenbank usw.) verwendet das integrierte [Datenbankgeheimnis](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html), das alle relevanten Felder automatisch aus der entsprechenden Datenbank füllt.

**Anmerkung**  
Der `dbname` Schlüssel ist optional. Abhängig von Ihrer Datenbankkonfiguration wird er in das Secret aufgenommen oder nicht. Sie können ihn dort manuell hinzufügen oder indem Sie der YAML-Datei den Namen geben.

## Andere Geheimnisse
<a name="ba-runtime-config-app-secrets-other"></a>

Andere Geheimnisse beziehen sich auf Ressourcen, die ein einziges Passwort haben (insbesondere passwortgeschützte Redis-Caches). In diesem Fall muss die [andere Art von](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) Geheimnis verwendet werden.

### YAML verweist auf Geheimnisse
<a name="ba-runtime-config-app-secrets-reference"></a>

`application-main.yml`Sie können auf den geheimen ARN für verschiedene Ressourcen verweisen:

### JICS-Datenbank
<a name="jics-database"></a>

Anmeldeinformationen für die JICS-Datenbank mit `spring.aws.jics.db.secret`

```
spring:
   aws:
     jics:
       db:
         dbname: jics
         secret: arn:aws:secretsmanager:XXXX
```

Unterstützte geheime JICS-Datenbankschlüssel:


| Geheimer Schlüssel | Beschreibung des geheimen Schlüssels | 
| --- | --- | 
| Host | Der Hostname | 
| port | Der Port | 
| dbname | Der Name der Datenbank | 
| username | Der Nutzername | 
| password | Das Passwort | 
| engine | Datenbank-Engine: Postgres, Oracle, Db2, Microsoft SQL Server | 
| Aktuelles Schema | Spezifisches Schema, das verwendet werden soll (nur Db2-Unterstützung) | 
| SSL-Verbindung | Ob die SSL-Verbindung verwendet werden soll (nur Db2-Unterstützung) | 
| sslTrustStoreSpeicherort | Der Speicherort des Truststores auf dem Client (nur Db2-Unterstützung) | 
| sslTrustStorePasswort | Das Passwort für den Truststore auf dem Client (nur Db2-Unterstützung) | 

**Anmerkung**  
Der Name der Datenbank wird entweder im Secret oder in der Yaml-Referenz angegeben. `spring.aws.jics.db.dbname`

### Blusam-Datenbank
<a name="blusam-database"></a>

BlusamDatenbankanmeldedaten mit `spring.aws.client.bluesam.db.secret`

```
spring:
   aws:
     client:
       bluesam:
         db:
           dbname: bluesam 
           secret: arn:aws:secretsmanager:XXXX
```

Unterstützte geheime Blusam Datenbankschlüssel:


| Geheimer Schlüssel | Beschreibung des geheimen Schlüssels | 
| --- | --- | 
| Host | Der Hostname | 
| port | Der Port | 
| dbname | Der Name der Datenbank | 
| username | Der Nutzername | 
| password | Das Passwort | 
| engine | Datenbank-Engine: Postgres | 

**Anmerkung**  
Der Name der Datenbank wird entweder im Secret oder in der Yaml-Referenz angegeben. `spring.aws.client.bluesam.db.dbname`

### Client-Datenbank
<a name="client-database"></a>

Der Client `application-profile.yml` kann auf den geheimen ARN für die Client-Datenbank verweisen. Dies erfordert eine zusätzliche Eigenschaft, um die Datenquellennamen aufzulisten. `spring.aws.client.datasources.names` `ds_name`Geben Sie für jeden Datenquellennamen den geheimen ARN in der folgenden Eigenschaft an:. `spring.aws.client.datasources.ds_name.secret` Beispiel:

```
spring:
   aws:
     client:
       datasources:
         names: primary,host 
         primary:
           secret: arn:aws:secretsmanager:XXXX
         host:
           dbname: hostdb 
           secret: arn:aws:secretsmanager:XXXX
```

*Namen: primär, Host:*

Ein Beispiel mit zwei Client-Datenquellen namens primary und host, jede mit ihrer Datenbank und ihren Anmeldeinformationen.

*Datenbankname*: hostdb:

In diesem Beispiel ist der Name der „Host“ -Datenbank nicht im Secret enthalten und wird stattdessen hier angegeben, während er für die „primäre“ Datenbank im Secret enthalten ist.

Unterstützte geheime Schlüssel der Client-Datenbank:


| Geheimer Schlüssel | Beschreibung des geheimen Schlüssels | 
| --- | --- | 
| Host | Der Hostname | 
| port | Der Port | 
| dbname | Der Name der Datenbank | 
| username | Der Nutzername | 
| password | Das Passwort | 
| engine | Datenbank-Engine: Postgres, Oracle, Db2, Microsoft SQL Server | 
| Aktuelles Schema | Spezifisches Schema, das verwendet werden soll (nur Db2-Unterstützung) | 
| SSL-Verbindung | Ob die SSL-Verbindung verwendet werden soll (nur Db2-Unterstützung) | 
| sslTrustStoreSpeicherort | Der Speicherort des Truststores auf dem Client (nur Db2-Unterstützung) | 
| sslTrustStorePasswort | Das Passwort für den Truststore auf dem Client (nur Db2-Unterstützung) | 

### PGM-Dienstprogrammdatenbank
<a name="pgm-utility-database"></a>

`application-utility-pgm.yml`Sie können auf den geheimen ARN für verschiedene Ressourcen verweisen.
+  `spring.aws.client.datasources.primary` 
  + `secret`

     Geheimer ARN für die Anwendungsdatenbank.

Type: Zeichenkette
+ `type`

Vollqualifizierter Name der zu verwendenden Verbindungspool-Implementierung.

Type: Zeichenkette

Standard: `com.zaxxer.hikari.HikariDataSource`
+ `spring.aws.client.utility.pgm.datasources` 
  + `names`

Liste der Datenquellennamen.

Type: Zeichenkette
+ `dsname` 
  + `dbname`

Name des Hosts.

Type: Zeichenkette
+ `secret`

Geheimer ARN der Host-Datenbank.

Type: Zeichenkette
+ `type`

Vollqualifizierter Name der zu verwendenden Verbindungspool-Implementierung.

Type: Zeichenkette

Standard: `com.zaxxer.hikari.HikariDataSource`

Für ein Geheimnis aus mehreren Datenquellen:

```
spring:
   aws:
     client:
       primary:
         secret: arn:aws:secretsmanager:XXXX
         type: dataSourceType
       utility:
         pgm:
           datasources:
             names: dsname1,dsname2,dsname3
               dsname1:
                 dbname: dbname1
                 secret: arn:aws:secretsmanager:XXXX
                 type: dataSourceType
               dsname2:
                 dbname: dbname2
                 secret: arn:aws:secretsmanager:XXXX
                 type: dataSourceType
               dsname3:
                 dbname: dbname3
                 secret: arn:aws:secretsmanager:XXXX
                 type: dataSourceType
```

### Keine von XA unterstützten geheimen Schlüssel
<a name="no-xa"></a>
+ Motor (postgres/oracle/db2/mssql)
+ port
+ dbname
+ Aktuelles Schema
+ username
+ password
+ URL
+ SSL-Verbindung
+ sslTrustStoreSpeicherort
+ sslTrustStorePasswort

Denn `postgres` nur der `sslMode` geheime Schlüssel value (`disable/allow/prefer/require/verify-ca/verify-full`) und die `spring.aws.rds.ssl.cert-path` YAML-Eigenschaft ermöglichen eine Verbindung mit SSL.

### XA unterstützte geheime Schlüssel
<a name="xa"></a>

Wenn die Client-Datenbank XA verwendet, werden die Sub-XA-Eigenschaften durch geheime Werte unterstützt.
+ Host
+ port
+ dbname
+ Aktuelles Schema
+ username
+ password
+ URL
+ SSL-Verbindung (wahr/falsch)
+ sslTrustStoreSpeicherort
+ sslTrustStorePasswort

Für andere Xa-Eigenschaften (zum Beispiel `maxPoolSize` oder`driverType`) `spring.jta.atomikos.datasource.XXXX.unique-resource-name` muss der reguläre YAML-Schlüssel jedoch weiterhin angegeben werden.

Der geheime Wert überschreibt die YAML-Eigenschaften.

### Standard Super Admin BAC und JAC
<a name="bac-and-jac"></a>

Sie können application-main.yml auch so konfigurieren, dass der Benutzername und das Passwort des standardmäßigen Super-Admin-Benutzers im Secret von AWS Secrets Manager abgerufen werden, indem Sie den ARN angeben. Das folgende Beispiel zeigt, wie dieses Geheimnis in einer YAML-Datei deklariert wird.

```
spring:
   aws:
     client:
       defaultSuperAdmin:
         secret: arn:aws:secretsmanager:XXXX
```

Unterstützte geheime Standardschlüssel für Super-Admin-Datenbanken:


| Geheimer Schlüssel | Beschreibung des geheimen Schlüssels | 
| --- | --- | 
| username | Benutzername | 
| password | Passwort | 

### OAuth2
<a name="oauth2"></a>

Sie können `application-main.yml` auch so konfigurieren, dass das OAuth2 Client-Geheimnis abgerufen wird, indem Sie den Anbieter und den ARN angeben. AWS Secrets Manager Der Standardwert für die Provider-Eigenschaft ist Amazon Cognito. Im Folgenden finden Sie eine Beispielkonfiguration für den OAuth2 Anbieter Keycloak:

```
spring:
   aws:
     client:
       provider: keycloak
       keycloak:
         secret: arn:aws:secretsmanager:XXXX
```

In diesem Beispiel wird das Client-Geheimnis für den OAuth2 Anbieter Keycloak aus dem angegebenen ARN in AWS Secrets Manager abgerufen. Diese Konfiguration unterstützt mehrere Anbieter, indem der Anbietername und der entsprechende geheime ARN dynamisch aufgelöst werden.

Unterstützte OAuth2 geheime Schlüssel:


| Geheimer Schlüssel | Beschreibung des geheimen Schlüssels | 
| --- | --- | 
| Geheim des Kunden | Das Geheimnis, das vom Autorisierungsserver während der Registrierung der Anwendung generiert wurde. | 

### Secret Manager für Redis-Caches
<a name="ba-runtime-redis-secrets-properties"></a>

Die `application-main.yml` Datei kann auf den geheimen ARN für Redis-Caches verweisen. Die unterstützten sind:
+ Gapwalk Redis-Anmeldeinformationen mit `spring.aws.client.gapwalk.redis.secret`
+ Bluesam Redis-Anmeldeinformationen mit `spring.aws.client.bluesam.redis.secret`
+ Bluesam sperrt Redis-Anmeldeinformationen mit `spring.aws.client.bluesam.locks.redis.secret`
+ Datensatzkatalog Redis-Anmeldeinformationen mit `spring.aws.client.dataset.catalog.redis.secret`
+ JICS Redis-Anmeldeinformationen mit `spring.aws.client.jics.redis.secret`
+ Redis-Anmeldeinformationen für die Sitzung mit `spring.aws.client.jics.redis.secret`
+ Redis-Anmeldeinformationen für den Sitzungs-Tracker mit `spring.aws.client.session.tracker.redis.secret`
+ JICS TS Queues Redis-Anmeldeinformationen mit `spring.aws.client.jics.queues.ts.redis.secret`
+ JCL-Checkpoint Redis-Anmeldeinformationen mit `spring.aws.client.jcl.checkpoint.redis.secret`
+ Gapwalk-Dateien sperren Redis-Anmeldeinformationen mit `spring.aws.client.gapwalk.files.locks.redis.secret`
+ Blu4iv sperrt Redis-Anmeldeinformationen mit `spring.aws.client.blu4iv.locks.redis.secret`

 Das folgende Beispiel zeigt, wie diese Geheimnisse in einer YAML-Datei deklariert werden.

```
spring:
   aws:
     client:
       gapwalk:
         redis:
           secret: arn:aws:secretsmanager:XXXX
       bluesam:
         locks:
           redis:
             secret: arn:aws:secretsmanager:XXXX
         redis:
           secret: arn:aws:secretsmanager:XXXX
       dataset:
         catalog:
           redis:
             secret: arn:aws:secretsmanager:XXXX
       jics:
         redis:
           secret: arn:aws:secretsmanager:XXXX
       session:
         tracker:
           redis:
             secret: arn:aws:secretsmanager:XXXX
       jics:
         queues:
           ts:
             redis:
               secret: arn:aws:secretsmanager:XXXX
       jcl:
         checkpoint:
           redis:
             secret: arn:aws:secretsmanager:XXXX
       gapwalk:
         files:
           locks:
             redis:
               secret: arn:aws:secretsmanager:XXXX
       blu4iv:
         locks:
           redis:
             secret: arn:aws:secretsmanager:XXXX
```

Unterstützte geheime Redis-Schlüssel:


| Geheimer Schlüssel | Beschreibung des geheimen Schlüssels | 
| --- | --- | 
| hostname | Der Hostname des Redis-Servers. | 
| port | Der Redis-Serverport. | 
| username | Benutzername | 
| password | Passwort | 

### Secret Manager für SSL-Passworteinstellungen
<a name="ba-runtime-ssl-secrets-properties"></a>

Die `application-main.yml` Datei kann auf den geheimen ARN für SSL-Passworteinstellungen verweisen. Folgendes wird unterstützt.
+ Gapwalk SSL-Anmeldeinformationen mit `spring.aws.client.ssl.secret`

Das folgende Beispiel zeigt, wie diese Geheimnisse in einer YAML-Datei deklariert werden.

```
spring:
   aws:
     client:
       ssl:
         secret: arn:aws:secretsmanager:XXXX
```


| Geheimer Schlüssel | Beschreibung des geheimen Schlüssels | 
| --- | --- | 
| trustStorePassword | Das Truststore-Passwort. | 
| keyStorePassword | Das Keystore-Passwort. | 

### Secret Manager für IBM MQ-Passworteinstellungen
<a name="ba-runtime-IBMMQ-secrets-properties"></a>

Die `application-main.yml` Datei kann auf den geheimen ARN für IBM MQ-Einstellungen verweisen. Folgendes wird unterstützt.
+ IBM MQ-Verbindungen sind als Liste definiert, ebenso wie die Anmeldeinformationen:

  `mq.queues.jmsMQQueueManagers[N].secret:`

  N beginnt bei der ersten Verbindung bei 0.

Das folgende Beispiel zeigt, wie diese Geheimnisse in einer YAML-Datei deklariert werden.

```
mq.queues.jmsMQQueueManagers[0].secret: Secret-0-ARN 
mq.queues.jmsMQQueueManagers[1].secret: Secret-1-ARN
```

Informationen zu Secrets ARNs Manager-Geheimnissen finden Sie unter [Was ist in einem Secrets Manager Manager-Geheimnis?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/whats-in-a-secret.html)

Im Secret definierte Eigenschaften überschreiben ihre entsprechenden Werte in der `jmsMQ` YAML-Konfiguration.

Wenn im Secret festgelegt `queueManager` ist, überschreibt es den `mq.queues.jmsMQQueueManagers[N].jmsMQQueueManager` Wert in der YAML-Datei.


| Geheimer Schlüssel | Beschreibung des geheimen Schlüssels | 
| --- | --- | 
| QueueManager | Der Name des IBM MQ-Warteschlangenmanagers. | 
| appName | Der Name der IBM MQ-Anwendung. | 
| channel | Der Name des IBM MQ-Kanals. | 
| Host | Der IBM MQ-Hostname. | 
| port | Der IBM MQ-Port. | 
| userId | Der IBM MQ-Benutzername. | 
| password | Das IBM MQ-Benutzerkennwort. | 
| maxPoolSize | Die maximale Poolgröße von IBM MQ. | 
| sslCipherKey | Die IBM MQ SSL Cipher Suite. | 

### JHDB-Datenbank
<a name="JHDB-database"></a>

Die `application-jhdb.yml` Client-Datei kann auf das Geheimnis ARNs für JHDB-Metadatendatenbanken verweisen. Jede Datenbankverbindung erfordert einen eindeutigen Namen und einen entsprechenden geheimen ARN, der die Verbindungsdaten enthält. Datenbanknamen werden in einer durch Kommas getrennten Liste definiert, wobei jedem Datenbanknamen ein individuelles Geheimnis ARNs zugeordnet ist.

```
spring:
   aws:
     jhdb:
       cnxs:
         datasources:
           names: DBD1,DBD2
           DBD1:  
             secret: arn:aws:secretsmanager:XXXX
           DBD2:
             secret: arn:aws:secretsmanager:XXXX
```

Unterstützte geheime Schlüssel der Client-Datenbank:


| Geheimer Schlüssel | Beschreibung des geheimen Schlüssels | 
| --- | --- | 
| Host | den Namen des Hosts | 
| port | Der Port. | 
| dbname | Name der Datenbank. | 
| username | Benutzername | 
| password | Passwort | 
| engine | Datenbank-Engine: Postgres (unterstützt jetzt nur Postgres). | 
| Aktuelles Schema | Spezifisches Schema, das verwendet werden soll. |