AWS O Mainframe Modernization Service (experiência em Managed Runtime Environment) não está mais aberto a novos clientes. Para recursos semelhantes ao AWS Mainframe Modernization Service (experiência em Managed Runtime Environment), explore o AWS Mainframe Modernization Service (experiência autogerenciada). Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte Alteração na [disponibilidade AWS da modernização do mainframe](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html).

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# AWS Transforme os segredos do Runtime para mainframe
<a name="ba-runtime-config-app-secrets"></a>

Algumas das configurações de recursos que contêm credenciais podem ser ainda mais protegidas usando segredos da AWS . A ideia é armazenar dados críticos em um AWS segredo e ter uma referência ao segredo na configuração YAML para que o conteúdo secreto seja coletado rapidamente na startup do Apache Tomcat.

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

A configuração do banco de dados do Aurora (para JICSBlusam, banco de dados do cliente etc.) usará o [segredo do banco de dados](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html) integrado, que preencherá automaticamente todos os campos relevantes do banco de dados correspondente.

**nota**  
A chave `dbname` é opcional, dependendo da configuração do seu banco de dados, ela entrará no segredo ou não. É possível adicioná-la manualmente ou fornecendo o nome ao arquivo YAML.

## Outros segredos
<a name="ba-runtime-config-app-secrets-other"></a>

Outros segredos são para recursos que têm uma única senha (principalmente caches redis protegidos por senha). Nesse caso, o [outro tipo de segredo](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) deve ser usado.

### Referências YAML a segredos
<a name="ba-runtime-config-app-secrets-reference"></a>

O `application-main.yml` pode consultar o ARN de vários recursos:

### Banco de dados JICS
<a name="jics-database"></a>

Credenciais do banco de dados JICS com `spring.aws.jics.db.secret`

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

Chaves secretas do banco de dados JICS compatíveis:


| Chave secreta | Descrição da chave secreta | 
| --- | --- | 
| host | O nome do host. | 
| porta | A porta. | 
| dbname | O nome do banco de dados. | 
| username | O nome de usuário. | 
| password | A senha. | 
| engine | Mecanismo de banco de dados: Postgres, Oracle, Db2, Microsoft SQL Server | 
| currentSchema | Esquema específico a ser usado (somente suporte ao Db2). | 
| sslConnection | Se deve usar a conexão SSL (somente suporte ao Db2). | 
| sslTrustStoreLocal | A localização do armazenamento confiável no cliente (somente suporte ao Db2). | 
| sslTrustStoreSenha | A senha do armazenamento confiável no cliente (somente suporte ao Db2). | 

**nota**  
O nome do banco de dados é fornecido no segredo ou na referência yaml `spring.aws.jics.db.dbname`.

### Banco de dados da Blusam
<a name="blusam-database"></a>

Blusamcredenciais de banco de dados com `spring.aws.client.bluesam.db.secret`

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

Chaves secretas Blusam de banco de dados suportadas:


| Chave secreta | Descrição da chave secreta | 
| --- | --- | 
| host | O nome do host. | 
| porta | A porta. | 
| dbname | O nome do banco de dados. | 
| username | O nome de usuário. | 
| password | A senha. | 
| engine | Mecanismo de banco de dados: Postgres | 

**nota**  
O nome do banco de dados é fornecido no segredo ou na referência yaml `spring.aws.client.bluesam.db.dbname`.

### Banco de dados de clientes
<a name="client-database"></a>

O cliente `application-profile.yml` pode referenciar o ARN secreto do banco de dados do cliente. Isso requer uma propriedade adicional para listar os nomes de fontes de dados `spring.aws.client.datasources.names`. Para cada nome de fonte de dados, `ds_name` especifique o ARN secreto na seguinte propriedade: `spring.aws.client.datasources.ds_name.secret`. Exemplo:

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

*nomes: primary,host*:

Um exemplo com duas fontes de dados de clientes chamadas primary e host, cada uma com seu banco de dados e credenciais.

*nome do banco de dados: hostdb*:

Neste exemplo, o nome do banco de dados “host” não está no segredo e é fornecido aqui, enquanto que para o banco de dados “primário” ele está no segredo.

Chaves secretas do banco de dados do cliente compatíveis:


| Chave secreta | Descrição da chave secreta | 
| --- | --- | 
| host | O nome do host. | 
| porta | A porta. | 
| dbname | O nome do banco de dados. | 
| username | O nome de usuário. | 
| password | A senha. | 
| engine | Mecanismo de banco de dados: Postgres, Oracle, Db2, Microsoft SQL Server | 
| currentSchema | Esquema específico a ser usado (somente suporte ao Db2). | 
| sslConnection | Se deve usar a conexão SSL (somente suporte ao Db2). | 
| sslTrustStoreLocal | A localização do armazenamento confiável no cliente (somente suporte ao Db2). | 
| sslTrustStoreSenha | A senha do armazenamento confiável no cliente (somente suporte ao Db2). | 

### Banco de dados de utilitários PGM
<a name="pgm-utility-database"></a>

O `application-utility-pgm.yml` pode consultar o ARN de segredo para vários recursos.
+  `spring.aws.client.datasources.primary` 
  + `secret`

     ARN de segredo para o banco de dados da aplicação.

Tipo: string
+ `type`

Nome totalmente qualificado da implementação do grupo de conexões a ser usado.

Tipo: string

Padrão: `com.zaxxer.hikari.HikariDataSource`
+ `spring.aws.client.utility.pgm.datasources` 
  + `names`

Lista de nomes de fontes de dados.

Tipo: string
+ `dsname` 
  + `dbname`

O nome do host.

Tipo: string
+ `secret`

ARN do segredo do banco de dados do host.

Tipo: string
+ `type`

Nome totalmente qualificado da implementação do grupo de conexões a ser usado.

Tipo: string

Padrão: `com.zaxxer.hikari.HikariDataSource`

Para um segredo de várias fontes de dados:

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

### Nenhuma chave secreta compatível com XA.
<a name="no-xa"></a>
+ motor (postgres/oracle/db2/mssql)
+ porta
+ dbname
+ currentSchema
+ username
+ password
+ url
+ sslConnection
+ sslTrustStoreLocal
+ sslTrustStoreSenha

Em relação a `postgres`, somente o valor da chave secreta `sslMode` (`disable/allow/prefer/require/verify-ca/verify-full`) e a propriedade `spring.aws.rds.ssl.cert-path` YAML possibilitam a conexão com SSL.

### Chaves secretas compatíveis com XA.
<a name="xa"></a>

Se o banco de dados do cliente estiver usando XA, as subpropriedades xa são aceitas por meio de valores do segredo.
+ host
+ porta
+ dbname
+ currentSchema
+ username
+ password
+ url
+ sslConnection (true/false)
+ sslTrustStoreLocal
+ sslTrustStoreSenha

No entanto, para outras propriedades xa (por exemplo, `maxPoolSize` ou `driverType`), a chave YAML normal `spring.jta.atomikos.datasource.XXXX.unique-resource-name` ainda deve ser fornecida.

O valor do segredo substitui as propriedades YAML.

### Superadmin BAC e JAC padrão
<a name="bac-and-jac"></a>

Também é possível configurar application-main.yml para recuperar o nome de usuário e a senha do usuário superadministrador padrão no segredo do AWS Secrets Manager especificando o ARN. O exemplo a seguir mostra como declarar esse segredo em um arquivo YAML.

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

Chaves secretas padrão do banco de dados superadmin aceitas:


| Chave secreta | Descrição da chave secreta | 
| --- | --- | 
| username | O nome de usuário. | 
| password | A senha. | 

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

Você também pode configurar `application-main.yml` para recuperar o OAuth2 segredo do cliente especificando o provedor e o ARN. AWS Secrets Manager O valor padrão para a propriedade do provedor é Amazon Cognito. Veja a seguir um exemplo de configuração para o OAuth2 provedor Keycloak:

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

Neste exemplo, o segredo do cliente do OAuth2 provedor Keycloak é recuperado do ARN especificado no AWS Secrets Manager. Essa configuração comporta vários provedores resolvendo dinamicamente o nome do provedor e o ARN do segredo correspondente.

Chaves OAuth2 secretas suportadas:


| Chave secreta | Descrição da chave secreta | 
| --- | --- | 
| client-secret | O segredo gerado pelo servidor de autorização durante o processo de registro da aplicação. | 

### Gerenciador de segredos para caches do Redis
<a name="ba-runtime-redis-secrets-properties"></a>

O arquivo `application-main.yml` pode fazer referência ao ARN do segredo para caches do Redis. Os aceitos são:
+ Credenciais do Redis do Gapwalk com `spring.aws.client.gapwalk.redis.secret`.
+ Credenciais do Redis do Bluesam com `spring.aws.client.bluesam.redis.secret`.
+ O Bluesam bloqueia as credenciais do Redis com `spring.aws.client.bluesam.locks.redis.secret`.
+ Credenciais do Redis do catálogo de conjuntos de dados com `spring.aws.client.dataset.catalog.redis.secret`.
+ Credenciais do Redis do JICS com `spring.aws.client.jics.redis.secret`.
+ Credenciais do Session Redis com `spring.aws.client.jics.redis.secret`.
+ Credenciais do Redis do rastreador de sessão com `spring.aws.client.session.tracker.redis.secret`.
+ Credenciais do Redis do JICS TS Queues com `spring.aws.client.jics.queues.ts.redis.secret`.
+ Credenciais do Redis de checkpoint do JCL com `spring.aws.client.jcl.checkpoint.redis.secret`.
+ Os arquivos do Gapwalk bloqueiam as credenciais do Redis com `spring.aws.client.gapwalk.files.locks.redis.secret`.
+ O Blu4IV bloqueia as credenciais do Redis com `spring.aws.client.blu4iv.locks.redis.secret`.

 O exemplo a seguir mostra como declarar esses segredos em um arquivo 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
```

Chaves secretas do Redis aceitas:


| Chave secreta | Descrição da chave secreta | 
| --- | --- | 
| hostname | O nome do host do servidor Redis. | 
| porta | A porta do servidor Redis. | 
| username | O nome de usuário. | 
| password | A senha. | 

### Gerenciador de segredos para configurações de senha SSL.
<a name="ba-runtime-ssl-secrets-properties"></a>

O arquivo `application-main.yml` pode fazer referência ao ARN do segredo para configurações de senha SSL. Os seguintes itens não são aceitos.
+ Credenciais SSL do Gapwalk com `spring.aws.client.ssl.secret`.

O exemplo a seguir mostra como declarar esses segredos em um arquivo YAML.

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


| Chave secreta | Descrição da chave secreta | 
| --- | --- | 
| trustStorePassword | A senha do armazenamento de confiança. | 
| keyStorePassword | A senha do armazenamento de chaves. | 

### Gerenciador de segredos para configurações de senha do IBM MQ.
<a name="ba-runtime-IBMMQ-secrets-properties"></a>

O `application-main.yml` arquivo pode referenciar o ARN secreto para as configurações do IBM MQ. Os seguintes itens não são aceitos.
+ As conexões do IBM MQ são definidas como uma lista, assim como as credenciais:

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

  N começa em 0 para a primeira conexão.

O exemplo a seguir mostra como declarar esses segredos em um arquivo YAML.

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

Para obter informações sobre segredos ARNs, consulte [O que há em um segredo do Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/whats-in-a-secret.html)

As propriedades definidas no segredo substituirão seus valores correspondentes na configuração `jmsMQ` YAML.

Se `queueManager` estiver definido no segredo, ele substituirá o `mq.queues.jmsMQQueueManagers[N].jmsMQQueueManager` valor no arquivo YAML.


| Chave secreta | Descrição da chave secreta | 
| --- | --- | 
| Gerenciador de filas | O nome do gerenciador de filas IBM MQ. | 
| appName | O nome do aplicativo IBM MQ. | 
| canal | O nome do canal IBM MQ. | 
| host | O nome do host IBM MQ. | 
| porta | A porta IBM MQ. | 
| userId | O nome de usuário do IBM MQ. | 
| password | A senha do usuário IBM MQ. | 
| maxPoolSize | O tamanho máximo do pool do IBM MQ. | 
| sslCipherKey | O pacote de criptografia IBM MQ SSL. | 

### Banco de dados JHDB
<a name="JHDB-database"></a>

O `application-jhdb.yml` arquivo do cliente pode referenciar o segredo ARNs para bancos de dados de metadados JHDB. Cada conexão de banco de dados requer um nome exclusivo e um ARN secreto correspondente contendo as credenciais de conexão. Os nomes dos bancos de dados são definidos em uma lista separada por vírgulas, com o segredo individual ARNs mapeado para cada nome do banco de dados.

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

Chaves secretas do banco de dados do cliente compatíveis:


| Chave secreta | Descrição da chave secreta | 
| --- | --- | 
| host | O nome do host. | 
| porta | A porta. | 
| dbname | O nome do banco de dados. | 
| username | O nome de usuário. | 
| password | A senha. | 
| engine | Mecanismo de banco de dados: Postgres (agora suporta somente Postgres). | 
| currentSchema | Esquema específico a ser usado. |