AWS Il servizio di modernizzazione del mainframe (esperienza Managed Runtime Environment) non è più aperto a nuovi clienti. Per funzionalità simili a AWS Mainframe Modernization Service (esperienza Managed Runtime Environment), esplora AWS Mainframe Modernization Service (Self-Managed Experience). I clienti esistenti possono continuare a utilizzare il servizio normalmente. [Per ulteriori informazioni, consulta AWS Modifica della disponibilità di Mainframe Modernization.](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html)

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# AWS I segreti di Transform for mainframe Runtime
<a name="ba-runtime-config-app-secrets"></a>

Alcune configurazioni di risorse che contengono credenziali possono essere ulteriormente protette utilizzando segreti. AWS L'idea è di archiviare i dati critici in un luogo AWS segreto e di inserire un riferimento a tale segreto nella configurazione YAML, in modo che il contenuto segreto venga raccolto all'avvio di Apache Tomcat.

## Segreti per Aurora
<a name="ba-runtime-config-app-secrets-aur"></a>

La configurazione del database Aurora (per JICSBlusam, customer db e così via) utilizzerà il [segreto del database](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html) integrato, che popolerà automaticamente tutti i campi pertinenti dal database corrispondente.

**Nota**  
La `dbname` chiave è facoltativa, a seconda della configurazione del database, entrerà nel segreto o meno. Puoi aggiungerla lì manualmente o fornendo il nome al file YAML.

## Altri segreti
<a name="ba-runtime-config-app-secrets-other"></a>

Altri segreti riguardano le risorse con un'unica password (in particolare le cache redis protette da password). In questo caso è necessario utilizzare l'[altro tipo di segreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

### Riferimenti YAML ai segreti
<a name="ba-runtime-config-app-secrets-reference"></a>

`application-main.yml`Possono fare riferimento all'ARN segreto per varie risorse:

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

Credenziali del database JICS con `spring.aws.jics.db.secret`

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

Chiavi segrete del database JICS supportate:


| Chiave privata | Descrizione della chiave segreta | 
| --- | --- | 
| host | Il nome dell'host | 
| port | La porta | 
| dbname | Il nome del database | 
| username | Il nome utente | 
| password | La password | 
| engine | Motore di database: Postgres, Oracle, Db2, Microsoft SQL Server | 
| Schema attuale | Schema specifico da utilizzare (solo supporto Db2) | 
| Connessione SSL | Se utilizzare la connessione SSL (solo supporto Db2) | 
| sslTrustStoreLocation | La posizione del truststore sul client (solo supporto Db2) | 
| sslTrustStorePassword | La password per il truststore sul client (solo supporto Db2) | 

**Nota**  
Il nome del database viene fornito nel segreto o nel riferimento yaml. `spring.aws.jics.db.dbname`

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

Blusamcredenziali del database con `spring.aws.client.bluesam.db.secret`

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

Chiavi segrete Blusam del database supportate:


| Chiave privata | Descrizione della chiave segreta | 
| --- | --- | 
| host | Il nome dell'host | 
| port | La porta | 
| dbname | Il nome del database | 
| username | Il nome utente | 
| password | La password | 
| engine | Motore di database: Postgres | 

**Nota**  
Il nome del database viene fornito nel segreto o nel riferimento yaml. `spring.aws.client.bluesam.db.dbname`

### Database client
<a name="client-database"></a>

Il client `application-profile.yml` può fare riferimento all'ARN segreto per il database del client. Ciò richiede una proprietà aggiuntiva per elencare i nomi delle sorgenti dati. `spring.aws.client.datasources.names` Per ogni nome di origine dati, `ds_name` specificare l'ARN segreto nella seguente proprietà:. `spring.aws.client.datasources.ds_name.secret` Esempio:

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

*nomi: primario, host:*

Un esempio con due origini dati client denominate primary e host, ognuna con il proprio database e le proprie credenziali.

dbname: *hostdb*:

In questo esempio, il nome del database «host» non è nel segreto e viene invece fornito qui, mentre per il database «primario» è nel segreto.

Chiavi segrete del database client supportate:


| Chiave privata | Descrizione della chiave segreta | 
| --- | --- | 
| host | Il nome dell'host | 
| port | La porta | 
| dbname | Il nome del database | 
| username | Il nome utente | 
| password | La password | 
| engine | Motore di database: Postgres, Oracle, Db2, Microsoft SQL Server | 
| Schema attuale | Schema specifico da utilizzare (solo supporto Db2) | 
| Connessione SSL | Se utilizzare la connessione SSL (solo supporto Db2) | 
| sslTrustStoreLocation | La posizione del truststore sul client (solo supporto Db2) | 
| sslTrustStorePassword | La password per il truststore sul client (solo supporto Db2) | 

### Database di utilità PGM
<a name="pgm-utility-database"></a>

`application-utility-pgm.yml`Possono fare riferimento all'ARN segreto per varie risorse.
+  `spring.aws.client.datasources.primary` 
  + `secret`

     ARN segreto per il database dell'applicazione.

Tipo: stringa
+ `type`

Nome completo dell'implementazione del pool di connessioni da utilizzare.

Tipo: stringa

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

Elenco dei nomi delle fonti di dati.

Tipo: stringa
+ `dsname` 
  + `dbname`

Nome dell'host.

Tipo: stringa
+ `secret`

ARN segreto del database host.

Tipo: stringa
+ `type`

Nome completo dell'implementazione del pool di connessioni da utilizzare.

Tipo: stringa

Impostazione predefinita: `com.zaxxer.hikari.HikariDataSource`

Per un segreto basato su più origini dati:

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

### Nessuna chiave segreta supportata da XA
<a name="no-xa"></a>
+ motore () postgres/oracle/db2/mssql
+ port
+ dbname
+ Schema corrente
+ username
+ password
+ url
+ Connessione SSL
+ sslTrustStoreLocation
+ sslTrustStorePassword

Perché `postgres` solo il valore della chiave `sslMode` segreta (`disable/allow/prefer/require/verify-ca/verify-full`) e la proprietà `spring.aws.rds.ssl.cert-path` YAML consentono la connessione con SSL.

### XA supportava le chiavi segrete
<a name="xa"></a>

Se il database del client utilizza XA, le proprietà xa secondarie sono supportate tramite valori segreti.
+ host
+ port
+ dbname
+ Schema corrente
+ username
+ password
+ url
+ Connessione SSL (vero/falso)
+ sslTrustStoreLocation
+ sslTrustStorePassword

Tuttavia, per altre proprietà xa (ad esempio `maxPoolSize` o`driverType`), `spring.jta.atomikos.datasource.XXXX.unique-resource-name` deve essere comunque fornita la normale chiave YAML.

Il valore segreto ha la precedenza sulle proprietà YAML.

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

Puoi anche configurare application-main.yml per recuperare il nome utente e la password dell'utente super amministratore predefinito nel segreto di AWS Secrets Manager specificando l'ARN. L'esempio seguente mostra come dichiarare questo segreto in un file YAML.

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

Chiavi segrete del database super admin predefinite supportate:


| Chiave privata | Descrizione della chiave segreta | 
| --- | --- | 
| username | Il nome utente. | 
| password | La password. | 

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

Puoi anche configurare `application-main.yml` per recuperare il OAuth2 segreto del client specificando il provider e l'ARN. Gestione dei segreti AWS Il valore predefinito per la proprietà del provider è Amazon Cognito. Di seguito è riportato un esempio di configurazione per il OAuth2 provider Keycloak:

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

In questo esempio, il client-secret per il OAuth2 provider Keycloak viene recuperato dall'ARN specificato in AWS Secrets Manager. Questa configurazione supporta più provider risolvendo dinamicamente il nome del provider e l'ARN segreto corrispondente.

Chiavi segrete supportate OAuth2 :


| Chiave privata | Descrizione della chiave segreta | 
| --- | --- | 
| segreto del cliente | Il segreto generato dal server di autorizzazione durante il processo di registrazione dell'applicazione. | 

### Gestore segreto per le cache Redis
<a name="ba-runtime-redis-secrets-properties"></a>

Il `application-main.yml` file può fare riferimento all'ARN segreto per le cache Redis. Quelle supportate sono:
+ Credenziali Gapwalk Redis con `spring.aws.client.gapwalk.redis.secret`
+ Credenziali Bluesam Redis con `spring.aws.client.bluesam.redis.secret`
+ Bluesam blocca le credenziali Redis con `spring.aws.client.bluesam.locks.redis.secret`
+ Dataset cataloga le credenziali Redis con `spring.aws.client.dataset.catalog.redis.secret`
+ Credenziali ICS Redis con `spring.aws.client.jics.redis.secret`
+ Credenziali Redis della sessione con `spring.aws.client.jics.redis.secret`
+ Credenziali Redis del tracker di sessione con `spring.aws.client.session.tracker.redis.secret`
+ JICS TS mette in coda le credenziali Redis con `spring.aws.client.jics.queues.ts.redis.secret`
+ Credenziali Redis del checkpoint JCL con `spring.aws.client.jcl.checkpoint.redis.secret`
+ I file Gapwalk bloccano le credenziali Redis con `spring.aws.client.gapwalk.files.locks.redis.secret`
+ Blu4iv blocca le credenziali Redis con `spring.aws.client.blu4iv.locks.redis.secret`

 L'esempio seguente mostra come dichiarare questi segreti in un file YAML.

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

Chiavi segrete Redis supportate:


| Chiave privata | Descrizione della chiave segreta | 
| --- | --- | 
| hostname | Il nome host del server Redis. | 
| port | La porta del server Redis. | 
| username | Il nome utente. | 
| password | La password. | 

### Gestore segreto per le impostazioni delle password SSL
<a name="ba-runtime-ssl-secrets-properties"></a>

Il `application-main.yml` file può fare riferimento all'ARN segreto per le impostazioni della password SSL. È supportato quanto segue.
+ Credenziali SSL Gapwalk con `spring.aws.client.ssl.secret`

L'esempio seguente mostra come dichiarare questi segreti in un file YAML.

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


| Chiave privata | Descrizione della chiave segreta | 
| --- | --- | 
| trustStorePassword | La password del truststore. | 
| keyStorePassword | La password del keystore. | 

### Gestore segreto per le impostazioni delle password di IBM MQ
<a name="ba-runtime-IBMMQ-secrets-properties"></a>

Il `application-main.yml` file può fare riferimento all'ARN segreto per le impostazioni IBM MQ. È supportato quanto segue.
+ Le connessioni IBM MQ sono definite come un elenco, così come le credenziali:

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

  N inizia da 0 per la prima connessione.

L'esempio seguente mostra come dichiarare questi segreti in un file YAML.

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

Per informazioni sul segreto ARNs, vedi [Cosa c'è in un segreto di Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/whats-in-a-secret.html)

Le proprietà definite nel segreto sovrascriveranno i valori corrispondenti nella configurazione `jmsMQ` YAML.

Se `queueManager` è impostato nel segreto, sovrascriverà il `mq.queues.jmsMQQueueManagers[N].jmsMQQueueManager` valore nel file YAML.


| Chiave privata | Descrizione della chiave segreta | 
| --- | --- | 
| QueueManager | Il nome del gestore di code IBM MQ. | 
| appName | Il nome dell'applicazione IBM MQ. | 
| channel | Il nome del canale IBM MQ. | 
| host | Il nome host IBM MQ. | 
| port | La porta IBM MQ. | 
| userId | Il nome utente IBM MQ. | 
| password | La password utente IBM MQ. | 
| maxPoolSize | La dimensione massima del pool IBM MQ. | 
| sslCipherKey | La suite di crittografia SSL IBM MQ. | 

### Database HDB
<a name="JHDB-database"></a>

Il `application-jhdb.yml` file client può fare riferimento al segreto ARNs per i database di metadati JHDB. Ogni connessione al database richiede un nome univoco e un ARN segreto corrispondente contenente le credenziali di connessione. I nomi dei database sono definiti in un elenco separato da virgole, con un segreto individuale ARNs mappato a ciascun nome di database.

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

Chiavi segrete del database client supportate:


| Chiave privata | Descrizione della chiave segreta | 
| --- | --- | 
| host | Il nome host. | 
| port | La porta. | 
| dbname | Nome del database. | 
| username | Il nome utente. | 
| password | La password. | 
| engine | Motore di database: Postgres (ora supporta solo Postgres). | 
| Schema attuale | Schema specifico da utilizzare. |