Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Obtenga secretos de AWS Secrets Manager
Secrets Manager genera una entrada de CloudTrail registro cuando recuperas un secreto. Para obtener más información, consulte [AWS Secrets Manager Registra eventos con AWS CloudTrail](monitoring-cloudtrail.md).
**Topics**
+ [Java](retrieving-secrets-java.md)
+ [Python](retrieving-secrets-python.md)
+ [.NET](retrieving-secrets-net.md)
+ [Go](retrieving-secrets-go.md)
+ [Rust](retrieving-secrets-rust.md)
+ [Amazon EKS](integrate_eks.md)
+ [AWS Lambda](retrieving-secrets_lambda.md)
+ [Agente de Secrets Manager](secrets-manager-agent.md)
+ [C\$1\$1](retrieving-secrets-cpp.md)
+ [JavaScript](retrieving-secrets-javascript.md)
+ [Kotlin](retrieving-secrets-kotlin.md)
+ [PHP](retrieving-secrets-php.md)
+ [Ruby](retrieving-secrets-ruby.md)
+ [AWS CLI](retrieving-secrets_cli.md)
+ [AWS consola](retrieving-secrets-console.md)
+ [AWS Batch](integrating_BATCH.md)
+ [CloudFormation](cfn-example_reference-secret.md)
+ [GitHub puestos de trabajo](retrieving-secrets_github.md)
+ [GitLab](integrating_gitlab.md)
+ [AWS IoT Greengrass](integrating-greengrass.md)
+ [Parameter Store:](integrating_parameterstore.md)
# Obtener un valor secreto de Secrets Manager con Java
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
Para conectarse a una base de datos mediante las credenciales de un secreto, puede utilizar los controladores de conexión SQL de Secrets Manager, que incluyen el controlador JDBC básico. Esto también utiliza el almacenamiento en caché del lado del cliente, por lo que puede reducir el costo de llamar a Secrets Manager. APIs
**Topics**
+ [Obtener un valor secreto de Secrets Manager mediante Java con almacenamiento en caché del cliente](retrieving-secrets_cache-java.md)
+ [Conéctese a una base de datos SQL mediante JDBC con las credenciales en secreto AWS Secrets Manager](retrieving-secrets_jdbc.md)
+ [Obtenga un valor secreto de Secrets Manager con el AWS SDK de Java](retrieving-secrets-java-sdk.md)
# Obtener un valor secreto de Secrets Manager mediante Java con almacenamiento en caché del cliente
Cuando recupera un secreto, puede utilizar el componente de almacenamiento en caché basado en Java de Secrets Manager para utilizarlo más adelante. Recuperar un secreto almacenado en la memoria caché es más rápido que recuperarlo desde Secrets Manager. Como llamar a Secrets Manager conlleva un coste APIs, el uso de una memoria caché puede reducir los costes. Para conocer todas las formas en las que puede recuperar secretos, consulte [Obtener secretos](retrieving-secrets.md).
La política de la caché consiste en el algoritmo menos usado recientemente (LRU), por lo que, cada vez que la caché tiene que descartar un secreto, lo hace con el de uso menos reciente. De forma predeterminada, la caché actualiza secretos cada hora. Puede configurar la [frecuencia con la que se actualiza el secreto](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL) en la memoria caché, y también [conectarse a la recuperación del secreto](retrieving-secrets_cache-java-ref_SecretCacheHook.md) para agregar más funcionalidad.
La memoria caché no fuerza la recopilación de elementos no utilizados una vez liberadas las referencias de la memoria caché. La implementación de la memoria caché no incluye la invalidación de la memoria caché. La implementación de la memoria caché se centra en la memoria caché en sí misma y no está reforzada ni centrada en la seguridad. Si necesita más seguridad, como cifrar elementos en la memoria caché, utilice las interfaces y los métodos abstractos que se proporcionan.
Para utilizar el componente, debe disponer de lo siguiente:
+ Un entorno de desarrollo Java 8 o una versión posterior. Consulte las [descargas de Java SE](https://www.oracle.com/technetwork/java/javase/downloads/index.html) en el sitio web de Oracle.
Para descargar el código fuente, consulte el componente de [cliente de almacenamiento en caché basado en Java de Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-java) en. GitHub
En el archivo pom.xml de Maven, incluya la siguiente dependencia para agregar el componente a su proyecto. Para obtener más información sobre Maven, consulte [Getting Started Guide](https://maven.apache.org/guides/getting-started/index.html) en el sitio web del proyecto de Apache Maven.
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información, consulte [Referencia de permisos](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md)
+ [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md)
+ [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md)
**Example Recuperación de un secreto**
En el siguiente ejemplo de código se muestra una función de Lambda que recupera una cadena del secreto. Sigue la [práctica recomendada](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) que consiste en crear una instancia de la memoria caché fuera del controlador de la función, para que no siga llamando a la API en caso de que se vuelva a invocar la función de Lambda.
```
package com.amazonaws.secretsmanager.caching.examples;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.secretsmanager.caching.SecretCache;
public class SampleClass implements RequestHandler {
private final SecretCache cache = new SecretCache();
@Override public String handleRequest(String secretId, Context context) {
final String secret = cache.getSecretString(secretId);
// Use the secret, return success;
}
}
```
# SecretCache
Una caché en memoria para los secretos solicitados a Secrets Manager. Utilice [getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) o [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary) para recuperar un secreto de la caché. Puede configurar los ajustes de la memoria caché si transfiere un objeto [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) en el constructor.
Para obtener más información, incluidos algunos ejemplos, consulte [Obtener un valor secreto de Secrets Manager mediante Java con almacenamiento en caché del cliente](retrieving-secrets_cache-java.md).
## Constructores
`public SecretCache()`
Constructor predeterminado de un objeto `SecretCache`.
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
Construye una nueva memoria caché con un cliente de Secrets Manager creado a partir del [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClientBuilder.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClientBuilder.html) proporcionado. Utilice este constructor para personalizar el cliente de Secrets Manager, por ejemplo, para utilizar una región o un punto de conexión específicos.
`public SecretCache(AWSSecretsManager client)`
Construye una nueva memoria caché del secreto mediante el [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) proporcionado. Utilice este constructor para personalizar el cliente de Secrets Manager, por ejemplo, para utilizar una región o un punto de conexión específicos.
`public SecretCache(SecretCacheConfiguration config)`
Construye una nueva memoria caché del secreto mediante el `SecretCacheConfiguration` proporcionado.
## Métodos
### getSecretString
`public String getSecretString(final String secretId)`
Recupera un secreto de cadena de Secrets Manager. Devuelve [https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true).
### getSecretBinary
`public ByteBuffer getSecretBinary(final String secretId)`
Recupera un secreto en formato binario desde Secrets Manager. Devuelve [https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html).
### refreshNow
`public boolean refreshNow(final String secretId) throws InterruptedException`
Obliga a la memoria caché a actualizarse. Devuelve `true` si la actualización se completa sin errores, en caso contrario, devuelve `false`.
### close
`public void close()`
Cierra la caché.
# SecretCacheConfiguration
Opciones de configuración de la caché para un [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), como el tamaño máximo de esta y el periodo de vida (TTL) de los secretos almacenados en ella.
## Constructor
`public SecretCacheConfiguration`
Constructor predeterminado de un objeto `SecretCacheConfiguration`.
## Métodos
### getClient
`public AWSSecretsManager getClient()`
Devuelve el [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) desde el cual la memoria caché recupera los secretos.
### setClient
`public void setClient(AWSSecretsManager client)`
Establece el [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) desde el cual la memoria caché recupera los secretos.
### getCacheHook
`public SecretCacheHook getCacheHook()`
Devuelve la interfaz [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilizada para conectar las actualizaciones de la caché.
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
Establece la interfaz [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilizada para conectar las actualizaciones de la caché.
### getMaxCacheTamaño
`public int getMaxCacheSize()`
Devuelve el tamaño máximo de la caché. El valor predeterminado es de 1024 secretos.
### setMaxCacheTamaño
`public void setMaxCacheSize(int maxCacheSize)`
Establece el tamaño máximo de la caché. El valor predeterminado es de 1024 secretos.
### getCacheItemTTL
`public long getCacheItemTTL()`
Devuelve el TTL en milisegundos de los elementos almacenados en la caché. Si un secreto almacenado en la caché supera este TTL, la caché recupera una nueva copia del secreto del [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). El valor predeterminado es de 1 hora en milisegundos.
La caché actualiza el secreto de forma sincrónica en el momento en que se solicita el secreto después del TTL. Si se produce un error en la actualización sincrónica, la caché devuelve el secreto obsoleto.
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
Establece el TTL en milisegundos de los elementos almacenados en la caché. Si un secreto almacenado en la caché supera este TTL, la caché recupera una nueva copia del secreto del [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). El valor predeterminado es de 1 hora en milisegundos.
### getVersionStage
`public String getVersionStage()`
Devuelve la versión de los secretos que desea almacenar en caché. Para obtener más información, consulte [Versiones del secreto](whats-in-a-secret.md#term_version). El valor predeterminado es ` "AWSCURRENT"`.
### setVersionStage
`public void setVersionStage(String versionStage)`
Establece la versión de los secretos que desea almacenar en caché. Para obtener más información, consulte [Versiones del secreto](whats-in-a-secret.md#term_version). El valor predeterminado es `"AWSCURRENT"`.
### SecretCacheConfiguration Con el cliente
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
Establece el [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) desde el cual se recuperan los secretos. Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
Establece la interfaz utilizada para conectarse a la caché en memoria. Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
### SecretCacheConfiguration withMaxCacheTamaño
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
Establece el tamaño máximo de la caché. Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
Establece el TTL en milisegundos de los elementos almacenados en la caché. Si un secreto almacenado en la caché supera este TTL, la caché recupera una nueva copia del secreto del [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). El valor predeterminado es de 1 hora en milisegundos. Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
Establece la versión de los secretos que desea almacenar en caché. Para obtener más información, consulte [Versiones del secreto](whats-in-a-secret.md#term_version). Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
# SecretCacheHook
Una interfaz para conectarse a una [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) y realizar acciones sobre los secretos almacenados en ella.
## put
`Object put(final Object o)`
Prepara el objeto para almacenarlo en la caché.
Devuelve el objeto que se almacenará en la caché.
## introducción
`Object get(final Object cachedObject)`
Deriva el objeto a partir del objeto almacenado en caché.
Devuelve el objeto que se devolverá de la caché
# Conéctese a una base de datos SQL mediante JDBC con las credenciales en secreto AWS Secrets Manager
En las aplicaciones Java, puede utilizar los controladores de conexión SQL de Secrets Manager para conectarse a bases de datos MySQL, PostgreSQL, Oracle MSSQLServer, Db2 y Redshift mediante las credenciales almacenadas en Secrets Manager. Cada controlador integra el controlador JDBC base, de modo que puede utilizar las llamadas JDBC para obtener acceso a su base de datos. Sin embargo, en lugar de indicar un nombre de usuario y una contraseña para conectarse, se proporciona el ID de un secreto. El controlador llama a Secrets Manager para recuperar el valor del secreto y, a continuación, utiliza las credenciales y la información de conexión que contiene el secreto para conectarse a la base de datos. El controlador también almacena en caché las credenciales mediante la [biblioteca de almacenamiento en caché del lado del cliente de Java](retrieving-secrets_cache-java.md), por lo que no es necesario llamar a Secrets Manager en futuras conexiones. La caché actualiza por defecto los secretos cada hora y también cuando se rota uno de ellos. Para configurar la caché, consulte [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md).
Puede descargar el código fuente en [GitHub](https://github.com/aws/aws-secretsmanager-jdbc ).
Para utilizar los controladores de conexión SQL de Secrets Manager:
+ Su aplicación debe tener Java 8 o una versión posterior.
+ El secreto debe ser uno de los siguientes:
+ Un [secreto de base de datos con la estructura JSON esperada](reference_secret_json_structure.md). Para comprobar el formato, en la consola de Secrets Manager, consulte su secreto y, a continuación, seleccione **Retrieve secret value** (Recuperar valor del secreto). O bien, en la llamada. AWS CLI[get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html)
+ Un [secreto administrado](integrating_how-services-use-secrets_RDS.md) de Amazon RDS. Para este tipo de secreto, debe especificar un punto de conexión y un puerto al establecer la conexión.
+ Un [secreto administrado](integrating_how-services-use-secrets_RS.md) de Amazon Redshift. Para este tipo de secreto, debe especificar un punto de conexión y un puerto al establecer la conexión.
Si la base de datos se replica en otras regiones, para conectarse a una base de datos de réplica de otra región, especifique el punto de conexión y el puerto regionales al crear la conexión. Puede almacenar la información de conexión regional en el secreto como key/value pares adicionales, en los parámetros del SSM Parameter Store o en la configuración de su código.
Para agregar el controlador al proyecto, en el archivo de compilación de Maven `pom.xml`, agregue la siguiente dependencia del controlador. Para obtener más información, consulte [Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc) en el sitio web del repositorio central de Maven.
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
El controlador utiliza la [https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html). Si ejecuta el controlador en Amazon EKS, es posible que recoja las credenciales del nodo en el que se ejecuta en lugar del rol de la cuenta de servicio. Para solucionar este problema, agregue la versión 1 de `com.amazonaws:aws-java-sdk-sts` a su archivo de proyecto de Gradle o Maven como una dependencia.
Para configurar una URL de punto final de AWS PrivateLink DNS y una región en el `secretsmanager.properties` archivo:
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
Para anular la región principal, defina la variable del entorno `AWS_SECRET_JDBC_REGION` o realice el siguiente cambio en el archivo `secretsmanager.properties`:
```
drivers.region = region
```
**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información, consulte [Referencia de permisos](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [Establecer una conexión a una base de datos](#retrieving-secrets_jdbc_example)
+ [Establecer una conexión especificando el punto de conexión y el puerto](#retrieving-secrets_jdbc_example_replica)
+ [Uso de la agrupación de conexiones c3p0 para establecer una conexión](#retrieving-secrets_jdbc_example_c3po)
+ [Uso de la agrupación de conexiones c3p0 para establecer una conexión especificando el punto de conexión y el puerto](#retrieving-secrets_jdbc_example_c3p0_replica)
## Establecer una conexión a una base de datos
En el siguiente ejemplo se muestra cómo establecer una conexión con una base de datos con las credenciales e información de conexión de un secreto. Una vez que tenga la conexión, puede utilizar las llamadas JDBC para obtener acceso a la base de datos. Para obtener más información, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) en el sitio web de documentación de Java.
------
#### [ MySQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ PostgreSQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Oracle ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ MSSQLServer ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Db2 ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Redshift ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
## Establecer una conexión especificando el punto de conexión y el puerto
En el siguiente ejemplo se muestra cómo establecer una conexión con una base de datos mediante las credenciales de un secreto con el punto de conexión y puerto que se especifique.
Los [secretos administrados de Amazon RDS](integrating_how-services-use-secrets_RDS.md) no incluyen el punto de conexión ni el puerto de la base de datos. Para conectarse a una base de datos mediante las credenciales maestras de un secreto administrado de Amazon RDS, hay que especificarlas en el código.
Los [secretos que se replican en otras regiones](replicate-secrets.md) pueden mejorar la latencia de la conexión a la base de datos regional, pero no contienen información de conexión distinta del secreto de origen. Cada réplica es una copia del secreto de origen. Para almacenar la información de conexión regional en el secreto, añada más key/value pares para el punto final y la información del puerto para las regiones.
Una vez que tenga la conexión, puede utilizar las llamadas JDBC para obtener acceso a la base de datos. Para obtener más información, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) en el sitio web de documentación de Java.
------
#### [ MySQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:mysql://example.com:3306";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ PostgreSQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:postgresql://example.com:5432/database";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Oracle ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:oracle:thin:@example.com:1521/ORCL";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ MSSQLServer ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:sqlserver://example.com:1433";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Db2 ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.com.rproxy.govskope.ca.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:db2://example.com:50000";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Redshift ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.com.rproxy.govskope.ca.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:redshift://example.com:5439";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
## Uso de la agrupación de conexiones c3p0 para establecer una conexión
En el siguiente ejemplo se muestra cómo establecer un grupo de conexiones con un archivo `c3p0.properties` que utiliza el controlador para recuperar las credenciales y la información de conexión del secreto. Para `user` y `jdbcUrl`, ingrese el ID del secreto y configure el grupo de conexiones. A continuación, puede recuperar las conexiones del grupo y utilizarlas como cualquier otra conexión de base de datos. Para obtener más información, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) en el sitio web de documentación de Java.
Para obtener más información sobre c3p0, consulte [c3p0](https://www.mchange.com/projects/c3p0/) en el sitio web Machinery For Change.
------
#### [ MySQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver
c3p0.jdbcUrl=secretId
```
------
#### [ PostgreSQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver
c3p0.jdbcUrl=secretId
```
------
#### [ Oracle ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver
c3p0.jdbcUrl=secretId
```
------
#### [ MSSQLServer ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver
c3p0.jdbcUrl=secretId
```
------
#### [ Db2 ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver
c3p0.jdbcUrl=secretId
```
------
#### [ Redshift ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver
c3p0.jdbcUrl=secretId
```
------
## Uso de la agrupación de conexiones c3p0 para establecer una conexión especificando el punto de conexión y el puerto
En el siguiente ejemplo, se muestra cómo establecer un grupo de conexiones con un archivo `c3p0.properties` que utiliza el controlador para recuperar las credenciales de un secreto con el punto de conexión y puerto que se especifique. A continuación, puede recuperar las conexiones del grupo y utilizarlas como cualquier otra conexión de base de datos. Para obtener más información, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) en el sitio web de documentación de Java.
Los [secretos administrados de Amazon RDS](integrating_how-services-use-secrets_RDS.md) no incluyen el punto de conexión ni el puerto de la base de datos. Para conectarse a una base de datos mediante las credenciales maestras de un secreto administrado de Amazon RDS, hay que especificarlas en el código.
Los [secretos que se replican en otras regiones](replicate-secrets.md) pueden mejorar la latencia de la conexión a la base de datos regional, pero no contienen información de conexión distinta del secreto de origen. Cada réplica es una copia del secreto de origen. Para almacenar la información de conexión regional en el secreto, añada más key/value pares para el punto final y la información del puerto para las regiones.
------
#### [ MySQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver
c3p0.jdbcUrl=jdbc-secretsmanager:mysql://example.com:3306
```
------
#### [ PostgreSQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver
c3p0.jdbcUrl=jdbc-secretsmanager:postgresql://example.com:5432/database
```
------
#### [ Oracle ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver
c3p0.jdbcUrl=jdbc-secretsmanager:oracle:thin:@example.com:1521/ORCL
```
------
#### [ MSSQLServer ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver
c3p0.jdbcUrl=jdbc-secretsmanager:sqlserver://example.com:1433
```
------
#### [ Db2 ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver
c3p0.jdbcUrl=jdbc-secretsmanager:db2://example.com:50000
```
------
#### [ Redshift ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver
c3p0.jdbcUrl=jdbc-secretsmanager:redshift://example.com:5439
```
------
# Obtenga un valor secreto de Secrets Manager con el AWS SDK de Java
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de los AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
+ Si almacena las credenciales de la base de datos en el secreto, utilice los [controladores de conexión SQL de Secrets Manager](retrieving-secrets_jdbc.md) para conectarse a una base de datos mediante esas credenciales.
+ Para otros tipos de secretos, utilice el [componente de almacenamiento en caché basado en Java de Secrets Manager](retrieving-secrets_cache-java.md) o llame al SDK directamente con [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/GetSecretValueResult.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/GetSecretValueResult.html) o [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/BatchGetSecretValueResult.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/BatchGetSecretValueResult.html).
Los siguientes ejemplos de código muestran cómo utilizar `GetSecretValue`.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueRequest;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueResponse;
import software.amazon.awssdk.services.secretsmanager.model.SecretsManagerException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* We recommend that you cache your secret values by using client-side caching.
*
* Caching secrets improves speed and reduces your costs. For more information,
* see the following documentation topic:
*
* https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html
*/
public class GetSecretValue {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
secretName - The name of the secret (for example, tutorials/MyFirstSecret).\s
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String secretName = args[0];
Region region = Region.US_EAST_1;
SecretsManagerClient secretsClient = SecretsManagerClient.builder()
.region(region)
.build();
getValue(secretsClient, secretName);
secretsClient.close();
}
public static void getValue(SecretsManagerClient secretsClient, String secretName) {
try {
GetSecretValueRequest valueRequest = GetSecretValueRequest.builder()
.secretId(secretName)
.build();
GetSecretValueResponse valueResponse = secretsClient.getSecretValue(valueRequest);
String secret = valueResponse.secretString();
System.out.println(secret);
} catch (SecretsManagerException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
# Obtener un valor secreto de Secrets Manager con Python
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
**Topics**
+ [Obtener un valor secreto de Secrets Manager mediante Python con almacenamiento en caché del cliente](retrieving-secrets_cache-python.md)
+ [Obtenga un valor secreto de Secrets Manager con el AWS SDK de Python](retrieving-secrets-python-sdk.md)
+ [Obtenga un lote de valores secretos de Secrets Manager con el AWS SDK de Python](retrieving-secrets-python-batch.md)
# Obtener un valor secreto de Secrets Manager mediante Python con almacenamiento en caché del cliente
Cuando recupera un secreto, puede utilizar el componente de almacenamiento en caché basado en Python de Secrets Manager para utilizarlo más adelante. Recuperar un secreto almacenado en la memoria caché es más rápido que recuperarlo desde Secrets Manager. Como llamar a Secrets Manager conlleva un coste APIs, el uso de una memoria caché puede reducir los costes. Para conocer todas las formas en las que puede recuperar secretos, consulte [Obtener secretos](retrieving-secrets.md).
La política de la caché consiste en el algoritmo menos usado recientemente (LRU), por lo que, cada vez que la caché tiene que descartar un secreto, lo hace con el de uso menos reciente. De forma predeterminada, la caché actualiza secretos cada hora. Puede configurar la [frecuencia con la que se actualiza el secreto](retrieving-secrets_cache-ref-secretcacheconfig.md) en la memoria caché, y también [conectarse a la recuperación del secreto](retrieving-secrets_cache-ref-secretcachehook.md) para agregar más funcionalidad.
La memoria caché no fuerza la recopilación de elementos no utilizados una vez liberadas las referencias de la memoria caché. La implementación de la memoria caché no incluye la invalidación de la memoria caché. La implementación de la memoria caché se centra en la memoria caché en sí misma y no está reforzada ni centrada en la seguridad. Si necesita más seguridad, como cifrar elementos en la memoria caché, utilice las interfaces y los métodos abstractos que se proporcionan.
Para utilizar el componente, debe disponer de lo siguiente:
+ Python 3.6 o posterior
+ botocore 1.12 o superior. Consulte [AWS SDK para Python](https://aws.amazon.com/sdk-for-python/) y [Botocore](https://botocore.amazonaws.com/v1/documentation/api/latest/index.html).
+ setuptools\$1scm 3.2 o superior. Consulte [https://pypi. org/project/setuptools-scm/](https://pypi.org/project/setuptools-scm/).
Para descargar el código fuente, consulte el componente de cliente de almacenamiento [en caché basado en Python de Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-python ) en. GitHub
Para instalar el componente, utilice el siguiente comando.
```
$ pip install aws-secretsmanager-caching
```
**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información, consulte [Referencia de permisos](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretCache](retrieving-secrets_cache-ref-secretcache.md)
+ [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md)
+ [SecretCacheHook](retrieving-secrets_cache-ref-secretcachehook.md)
+ [@InjectSecretString](retrieving-secrets_cache-decor-string.md)
+ [@InjectKeywordedSecretString](retrieving-secrets_cache-decor-keyword.md)
**Example Recuperación de un secreto**
El siguiente ejemplo muestra cómo obtener el valor secreto de un secreto denominado. *mysecret*
```
import botocore
import botocore.session
from aws_secretsmanager_caching import SecretCache, SecretCacheConfig
client = botocore.session.get_session().create_client('secretsmanager')
cache_config = SecretCacheConfig()
cache = SecretCache( config = cache_config, client = client)
secret = cache.get_secret_string('mysecret')
```
# SecretCache
Una caché en memoria para los secretos recuperados de Secrets Manager. Utilice [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string) o [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary) para recuperar un secreto de la caché. Puede configurar los ajustes de la memoria caché si transfiere un objeto [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md) en el constructor.
Para obtener más información, incluidos algunos ejemplos, consulte [Obtener un valor secreto de Secrets Manager mediante Python con almacenamiento en caché del cliente](retrieving-secrets_cache-python.md).
```
cache = SecretCache(
config = SecretCacheConfig,
client = [client](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html)
)
```
**Topics**
+ [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string)
+ [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary)
## get\$1secret\$1string
Recupera el valor de la cadena del secreto.
Sintaxis de la solicitud
```
response = cache.get_secret_string(
secret_id='string',
version_stage='string' )
```
Parameters
+ `secret_id` (*cadena*): [obligatorio] el nombre o ARN del secreto.
+ `version_stage` (*cadena*): la versión de los secretos que desea recuperar. Para obtener más información, consulte [versiones del secreto](whats-in-a-secret.md). El valor predeterminado es 'AWSCURRENT'.
Tipo de devolución
cadena
## get\$1secret\$1binary
Recupera el valor binario del secreto.
Sintaxis de la solicitud
```
response = cache.get_secret_binary(
secret_id='string',
version_stage='string'
)
```
Parameters
+ `secret_id` (*cadena*): [obligatorio] el nombre o ARN del secreto.
+ `version_stage` (*cadena*): la versión de los secretos que desea recuperar. Para obtener más información, consulte [versiones del secreto](whats-in-a-secret.md). El valor predeterminado es 'AWSCURRENT'.
Tipo de devolución
Cadena [codificada en base64](https://tools.ietf.org/html/rfc4648#section-4)
# SecretCacheConfig
Opciones de configuración de la caché para un [SecretCache](retrieving-secrets_cache-ref-secretcache.md), como el tamaño máximo de esta y el periodo de vida (TTL) de los secretos almacenados en ella.Parameters
`max_cache_size` (*int*)
El tamaño máximo de la caché. El valor predeterminado es de `1024` secretos.
`exception_retry_delay_base` (*int*)
La cantidad de segundos que se debe esperar luego de que se haya producido una excepción antes de reintentar la solicitud. El valor predeterminado es `1`.
`exception_retry_growth_factor` (*int*)pur
El factor de crecimiento que se debe utilizar para calcular el tiempo de espera entre los reintentos de las solicitudes en las que se haya producido un error. El valor predeterminado es `2`.
`exception_retry_delay_max` (*int*)
La cantidad máxima de tiempo en segundos que se debe esperar entre las solicitudes en las que se haya producido un error. El valor predeterminado es `3600`.
`default_version_stage` (*str*)
La versión de los secretos que desea almacenar en caché. Para obtener más información, consulte [Versiones del secreto](whats-in-a-secret.md#term_version). El valor predeterminado es `'AWSCURRENT'`.
`secret_refresh_interval` (*int*)
La cantidad de segundos que se debe esperar entre la actualización de la información del secreto en la caché. El valor predeterminado es `3600`.
`secret_cache_hook` (*SecretCacheHook*)
Implementación de la clase abstracta `SecretCacheHook`. El valor predeterminado es `None`.
# SecretCacheHook
Una interfaz para conectarse a una [SecretCache](retrieving-secrets_cache-ref-secretcache.md) y realizar acciones sobre los secretos almacenados en ella.
**Topics**
+ [put](#retrieving-secrets_cache-ref-secretcachehook_put)
+ [introducción](#retrieving-secrets_cache-ref-secretcachehook_get)
## put
Prepara el objeto para almacenarlo en la caché.
Sintaxis de la solicitud
```
response = hook.put(
obj='secret_object'
)
```
Parameters
+ `obj` (*objeto*): [obligatorio] el secreto o el objeto que contiene el secreto.
Tipo de devolución
objeto
## introducción
Deriva el objeto a partir del objeto almacenado en caché.
Sintaxis de la solicitud
```
response = hook.get(
obj='secret_object'
)
```
Parameters
+ `obj` (*objeto*): [obligatorio] el secreto o el objeto que contiene el secreto.
Tipo de devolución
objeto
# @InjectSecretString
Este elemento Decorator espera una cadena de ID del secreto y una [SecretCache](retrieving-secrets_cache-ref-secretcache.md) como primer y segundo argumento. El elemento Decorator devuelve el valor de la cadena del secreto. El nombre del secreto debe contener una cadena.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectSecretString ( 'mysecret' , cache )
def function_to_be_decorated( arg1, arg2, arg3):
```
# @InjectKeywordedSecretString
Este elemento Decorator espera una cadena de ID del secreto y una [SecretCache](retrieving-secrets_cache-ref-secretcache.md) como primer y segundo argumento. Los argumentos restantes asignan parámetros de la función integrada a las claves JSON del secreto. El secreto debe contener una cadena en la estructura JSON.
Para un secreto que contenga este JSON:
```
{
"username": "saanvi",
"password": "EXAMPLE-PASSWORD"
}
```
En el siguiente ejemplo se muestra cómo extraer los valores JSON de `username` y `password` del secreto.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectKeywordedSecretString ( secret_id = 'mysecret' , cache = cache , func_username = 'username' , func_password = 'password' )
def function_to_be_decorated( func_username, func_password):
print( 'Do something with the func_username and func_password parameters')
```
# Obtenga un valor secreto de Secrets Manager con el AWS SDK de Python
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
Para aplicaciones Python, utilice el [componente de almacenamiento en caché basado en Python de Secrets Manager](retrieving-secrets_cache-python.md) o llame directamente al SDK con [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html) o [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html).
Los siguientes ejemplos de código muestran cómo utilizar `GetSecretValue`.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
"""
Purpose
Shows how to use the AWS SDK for Python (Boto3) with AWS
Secrets Manager to get a specific of secrets that match a
specified name
"""
import boto3
import logging
from get_secret_value import GetSecretWrapper
# Configure logging
logging.basicConfig(level=logging.INFO)
def run_scenario(secret_name):
"""
Retrieve a secret from AWS Secrets Manager.
:param secret_name: Name of the secret to retrieve.
:type secret_name: str
"""
try:
# Validate secret_name
if not secret_name:
raise ValueError("Secret name must be provided.")
# Retrieve the secret by name
client = boto3.client("secretsmanager")
wrapper = GetSecretWrapper(client)
secret = wrapper.get_secret(secret_name)
# Note: Secrets should not be logged.
return secret
except Exception as e:
logging.error(f"Error retrieving secret: {e}")
raise
class GetSecretWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def get_secret(self, secret_name):
"""
Retrieve individual secrets from AWS Secrets Manager using the get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param secret_name: The name of the secret fetched.
:type secret_name: str
"""
try:
get_secret_value_response = self.client.get_secret_value(
SecretId=secret_name
)
logging.info("Secret retrieved successfully.")
return get_secret_value_response["SecretString"]
except self.client.exceptions.ResourceNotFoundException:
msg = f"The requested secret {secret_name} was not found."
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred: {str(e)}.")
raise
```
# Obtenga un lote de valores secretos de Secrets Manager con el AWS SDK de Python
En el siguiente ejemplo de código se muestra cómo obtener un lote de valores secretos de Secrets Manager.
**Permisos necesarios: **
+ `secretsmanager:BatchGetSecretValue`
+ Permiso `secretsmanager:GetSecretValue` para cada uno de los secretos que desea recuperar.
+ Si utiliza filtros, también debe tenerlos `secretsmanager:ListSecrets`.
Si desea ver un ejemplo de política de permisos, consulte [Ejemplo: permiso para recuperar un grupo de valores secretos en un lote](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**importante**
Si tiene una política de VPCE que deniega el permiso para recuperar un secreto individual del grupo en recuperación, `BatchGetSecretValue` no devolverá ningún valor secreto y mostrará un error.
```
class BatchGetSecretsWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def batch_get_secrets(self, filter_name):
"""
Retrieve multiple secrets from AWS Secrets Manager using the batch_get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param filter_name: The full or partial name of secrets to be fetched.
:type filter_name: str
"""
try:
secrets = []
response = self.client.batch_get_secret_value(
Filters=[{"Key": "name", "Values": [f"{filter_name}"]}]
)
for secret in response["SecretValues"]:
secrets.append(json.loads(secret["SecretString"]))
if secrets:
logger.info("Secrets retrieved successfully.")
else:
logger.info("Zero secrets returned without error.")
return secrets
except self.client.exceptions.ResourceNotFoundException:
msg = f"One or more requested secrets were not found with filter: {filter_name}"
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred:\n{str(e)}.")
raise
```
# Obtener un valor secreto de Secrets Manager con .NET
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
**Topics**
+ [Obtener un valor secreto de Secrets Manager mediante .NET con almacenamiento en caché del cliente](retrieving-secrets_cache-net.md)
+ [Obtenga un valor secreto de Secrets Manager utilizando el SDK para .NET](retrieving-secrets-net-sdk.md)
# Obtener un valor secreto de Secrets Manager mediante .NET con almacenamiento en caché del cliente
Cuando recupera un secreto, puede utilizar el componente de almacenamiento en caché basado en .NET de Secrets Manager para utilizarlo más adelante. Recuperar un secreto almacenado en la memoria caché es más rápido que recuperarlo desde Secrets Manager. Como llamar a Secrets Manager conlleva un coste APIs, el uso de una memoria caché puede reducir los costes. Para conocer todas las formas en las que puede recuperar secretos, consulte [Obtener secretos](retrieving-secrets.md).
La política de la caché consiste en el algoritmo menos usado recientemente (LRU), por lo que, cada vez que la caché tiene que descartar un secreto, lo hace con el de uso menos reciente. De forma predeterminada, la caché actualiza secretos cada hora. Puede configurar la [frecuencia con la que se actualiza el secreto](retrieving-secrets_cache-net-SecretCacheConfiguration.md#retrieving-secrets_cache-net-SecretCacheConfiguration-properties_CacheItemTTL) en la memoria caché, y también [conectarse a la recuperación del secreto](retrieving-secrets_cache-net-ISecretCacheHook.md) para agregar más funcionalidad.
La memoria caché no fuerza la recopilación de elementos no utilizados una vez liberadas las referencias de la memoria caché. La implementación de la memoria caché no incluye la invalidación de la memoria caché. La implementación de la memoria caché se centra en la memoria caché en sí misma y no está reforzada ni centrada en la seguridad. Si necesita más seguridad, como cifrar elementos en la memoria caché, utilice las interfaces y los métodos abstractos que se proporcionan.
Para utilizar el componente, debe disponer de lo siguiente:
+ .NET Framework 4.6.2 o una versión posterior, o .NET Standard 2.0 o una versión posterior. Consulte [Download .NET](https://dotnet.microsoft.com/en-us/download) (Descargar .NET) en el sitio web de Microsoft .NET.
+ El AWS SDK para .NET. Consulte [AWS SDKs](asm_access.md#asm-sdks).
Para descargar el código fuente, consulte [Cliente de almacenamiento en caché para .NET](https://github.com/aws/aws-secretsmanager-caching-net ) on GitHub.
Para utilizar la caché, primero hay que crear una instancia y, a continuación, recuperar el secreto mediante `GetSecretString` o `GetSecretBinary`. En las recuperaciones posteriores, la caché devuelve la copia almacenada del secreto.
**Para obtener el paquete de almacenamiento en caché**
+ Realice una de las siguientes acciones:
+ Ejecute el siguiente comando de la CLI de .NET en el directorio del proyecto.
```
dotnet add package AWSSDK.SecretsManager.Caching --version 1.0.6
```
+ Agregue la siguiente referencia de paquete al archivo `.csproj`.
```
```
**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información, consulte [Referencia de permisos](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md)
+ [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md)
+ [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md)
**Example Recuperación de un secreto**
En el siguiente ejemplo de código se muestra un método que recupera un secreto denominado. *MySecret*
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName ="MySecret";
private SecretsManagerCache cache = new SecretsManagerCache();
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string MySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
**Example Configurar la duración de la actualización de la memoria caché del tiempo de vida (TTL)**
El siguiente ejemplo de código muestra un método que recupera un secreto denominado *MySecret* y establece la duración de la actualización de la caché TTL en 24 horas.
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName = "MySecret";
private static SecretCacheConfiguration cacheConfiguration = new SecretCacheConfiguration
{
CacheItemTTL = 86400000
};
private SecretsManagerCache cache = new SecretsManagerCache(cacheConfiguration);
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string mySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
# SecretsManagerCache
Una caché en memoria para los secretos solicitados a Secrets Manager. Utilice [GetSecretString](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretString) o [GetSecretBinary](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretBinary) para recuperar un secreto de la caché. Puede configurar los ajustes de la memoria caché si transfiere un objeto [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) en el constructor.
Para obtener más información, incluidos algunos ejemplos, consulte [Obtener un valor secreto de Secrets Manager mediante .NET con almacenamiento en caché del cliente](retrieving-secrets_cache-net.md).
## Constructores
`public SecretsManagerCache()`
Constructor predeterminado de un objeto `SecretsManagerCache`.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager)`
Construye una nueva memoria caché con un cliente de Secrets Manager creado a partir del [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html) proporcionado. Utilice este constructor para personalizar el cliente de Secrets Manager, como por ejemplo, para utilizar una región o un punto de conexión específicos.
**Parameters**
secretsManager
El del que [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)se van a recuperar los secretos.
`public SecretsManagerCache(SecretCacheConfiguration config)`
Construye una nueva caché del secreto mediante el [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) proporcionado. Utilice este constructor para configurar la memoria caché, por ejemplo, la cantidad de secretos que se almacenarán en la caché y la frecuencia con la que se actualizará.
**Parameters**
config
Una [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) que contiene información de configuración de la caché.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager, SecretCacheConfiguration config)`
Construye una nueva caché mediante un cliente Secrets Manager creado con el proporcionado [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)y un[SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md). Utilice este constructor para personalizar el cliente de Secrets Manager, por ejemplo, para utilizar una región o un punto de conexión específicos, así como para configurar la caché, por ejemplo, la cantidad de secretos que se almacenarán en la caché y la frecuencia con la que se actualizará.
**Parameters**
secretsManager
El [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)para recuperar secretos.
config
Una [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) que contiene información de configuración de la caché.
## Métodos
### GetSecretString
`public async Task GetSecretString(String secretId)`
Recupera un secreto de cadena de Secrets Manager.Parameters
secretId
El ARN o nombre del secreto que hay que recuperar.
### GetSecretBinary
`public async Task GetSecretBinary(String secretId)`
Recupera un secreto en formato binario desde Secrets Manager.Parameters
secretId
El ARN o nombre del secreto que hay que recuperar.
### RefreshNowAsync
`public async Task RefreshNowAsync(String secretId)`
Solicita el valor del secreto a Secrets Manager y actualiza la caché con los cambios que se hayan producido. Si no hay ninguna entrada en la caché, creará una nueva. Devuelve `true` si la actualización se realiza correctamente.Parameters
secretId
El ARN o nombre del secreto que hay que recuperar.
### GetCachedSecret
`public SecretCacheItem GetCachedSecret(string secretId)`
Devuelve la entrada de la caché para el secreto especificado si existe en la memoria. En caso contrario, recupera el secreto desde Secrets Manager y crea una nueva entrada en la caché.Parameters
secretId
El ARN o nombre del secreto que hay que recuperar.
# SecretCacheConfiguration
Opciones de configuración de la caché para un [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md), como el tamaño máximo de esta y el periodo de vida (TTL) de los secretos almacenados en ella.
## Propiedades
### CacheItemTTL
`public uint CacheItemTTL { get; set; }`
El TTL de un elemento de la caché en milisegundos. El valor predeterminado es de `3600000` ms o 1 hora. El máximo es `4294967295` ms, que son aproximadamente 49,7 días.
### MaxCacheSize
`public ushort MaxCacheSize { get; set; }`
El tamaño máximo de la caché. El valor predeterminado es de 1024 secretos. El máximo es 65 535.
### VersionStage
`public string VersionStage { get; set; }`
La versión de los secretos que desea almacenar en caché. Para obtener más información, consulte [Versiones del secreto](whats-in-a-secret.md#term_version). El valor predeterminado es `"AWSCURRENT"`.
### Cliente
`public IAmazonSecretsManager Client { get; set; }`
Los de [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)los que recuperar secretos. Si es `null`, la caché crea instancias de un nuevo cliente. El valor predeterminado es `null`.
### CacheHook
`public ISecretCacheHook CacheHook { get; set; }`
Una [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md).
# ISecretCacheHook
Una interfaz para conectarse a una [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md) y realizar acciones sobre los secretos almacenados en ella.
## Métodos
### Put
`object Put(object o);`
Prepara el objeto para almacenarlo en la caché.
Devuelve el objeto que se almacenará en la caché.
### Get
`object Get(object cachedObject);`
Deriva el objeto a partir del objeto almacenado en caché.
Devuelve el objeto que se devolverá de la caché
# Obtenga un valor secreto de Secrets Manager utilizando el SDK para .NET
En las aplicaciones, puedes recuperar tus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
Para aplicaciones .NET, utilice el [componente de almacenamiento en caché basado en .NET de Secrets Managero](retrieving-secrets_cache-net.md) o llame al SDK directamente con [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html) o [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html).
Los siguientes ejemplos de código muestran cómo utilizar `GetSecretValue`.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
using System;
using System.IO;
using System.Threading.Tasks;
using Amazon.SecretsManager;
using Amazon.SecretsManager.Model;
///
/// This example uses the Amazon Web Service Secrets Manager to retrieve
/// the secret value for the provided secret name.
///
public class GetSecretValue
{
///
/// The main method initializes the necessary values and then calls
/// the GetSecretAsync and DecodeString methods to get the decoded
/// secret value for the secret named in secretName.
///
public static async Task Main()
{
string secretName = "<<{{MySecretName}}>>";
string secret;
IAmazonSecretsManager client = new AmazonSecretsManagerClient();
var response = await GetSecretAsync(client, secretName);
if (response is not null)
{
secret = DecodeString(response);
if (!string.IsNullOrEmpty(secret))
{
Console.WriteLine($"The decoded secret value is: {secret}.");
}
else
{
Console.WriteLine("No secret value was returned.");
}
}
}
///
/// Retrieves the secret value given the name of the secret to
/// retrieve.
///
/// The client object used to retrieve the secret
/// value for the given secret name.
/// The name of the secret value to retrieve.
/// The GetSecretValueReponse object returned by
/// GetSecretValueAsync.
public static async Task GetSecretAsync(
IAmazonSecretsManager client,
string secretName)
{
GetSecretValueRequest request = new GetSecretValueRequest()
{
SecretId = secretName,
VersionStage = "AWSCURRENT", // VersionStage defaults to AWSCURRENT if unspecified.
};
GetSecretValueResponse response = null;
// For the sake of simplicity, this example handles only the most
// general SecretsManager exception.
try
{
response = await client.GetSecretValueAsync(request);
}
catch (AmazonSecretsManagerException e)
{
Console.WriteLine($"Error: {e.Message}");
}
return response;
}
///
/// Decodes the secret returned by the call to GetSecretValueAsync and
/// returns it to the calling program.
///
/// A GetSecretValueResponse object containing
/// the requested secret value returned by GetSecretValueAsync.
/// A string representing the decoded secret value.
public static string DecodeString(GetSecretValueResponse response)
{
// Decrypts secret using the associated AWS Key Management Service
// Customer Master Key (CMK.) Depending on whether the secret is a
// string or binary value, one of these fields will be populated.
if (response.SecretString is not null)
{
var secret = response.SecretString;
return secret;
}
else if (response.SecretBinary is not null)
{
var memoryStream = response.SecretBinary;
StreamReader reader = new StreamReader(memoryStream);
string decodedBinarySecret = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(reader.ReadToEnd()));
return decodedBinarySecret;
}
else
{
return string.Empty;
}
}
}
```
# Obtener un valor secreto de Secrets Manager con Go
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
**Topics**
+ [Obtener un valor secreto de Secrets Manager mediante Go con almacenamiento en caché del cliente](retrieving-secrets_cache-go.md)
+ [Obtén un valor secreto de Secrets Manager con el AWS SDK de Go](retrieving-secrets-go-sdk.md)
# Obtener un valor secreto de Secrets Manager mediante Go con almacenamiento en caché del cliente
Cuando recupera un secreto, puede utilizar el componente de almacenamiento en caché basado en Go de Secrets Manager para utilizarlo más adelante. Recuperar un secreto almacenado en la memoria caché es más rápido que recuperarlo desde Secrets Manager. Como llamar a Secrets Manager conlleva un coste APIs, el uso de una memoria caché puede reducir los costes. Para conocer todas las formas en las que puede recuperar secretos, consulte [Obtener secretos](retrieving-secrets.md).
La política de la caché consiste en el algoritmo menos usado recientemente (LRU), por lo que, cada vez que la caché tiene que descartar un secreto, lo hace con el de uso menos reciente. De forma predeterminada, la caché actualiza secretos cada hora. Puede configurar la [frecuencia con la que se actualiza el secreto](retrieving-secrets_cache-go_CacheConfig.md) en la memoria caché, y también [conectarse a la recuperación del secreto](retrieving-secrets_cache-go_CacheHook.md) para agregar más funcionalidad.
La memoria caché no fuerza la recopilación de elementos no utilizados una vez liberadas las referencias de la memoria caché. La implementación de la memoria caché no incluye la invalidación de la memoria caché. La implementación de la memoria caché se centra en la memoria caché en sí misma y no está reforzada ni centrada en la seguridad. Si necesita más seguridad, como cifrar elementos en la memoria caché, utilice las interfaces y los métodos abstractos que se proporcionan.
Para utilizar el componente, debe disponer de lo siguiente:
+ AWS SDK for Go. Consulte [AWS SDKs](asm_access.md#asm-sdks).
Para descargar el código fuente, consulte el [cliente de almacenamiento en GitHub caché Secrets Manager Go](https://github.com/aws/aws-secretsmanager-caching-go ) activado.
Para configurar un entorno de desarrollo Go, consulte [Golang Getting Started](https://golang.org/doc/install) en el sitio web del lenguaje de programación Go.
**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información, consulte [Referencia de permisos](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [type Cache](retrieving-secrets_cache-go_cache.md)
+ [escriba CacheConfig](retrieving-secrets_cache-go_CacheConfig.md)
+ [tipo CacheHook](retrieving-secrets_cache-go_CacheHook.md)
**Example Recuperación de un secreto**
En el siguiente ejemplo de código se muestra una función de Lambda que recupera un secreto.
```
package main
import (
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-secretsmanager-caching-go/secretcache"
)
var (
secretCache, _ = secretcache.New()
)
func HandleRequest(secretId string) string {
result, _ := secretCache.GetSecretString(secretId)
// Use the secret, return success
}
func main() {
lambda. Start( HandleRequest)
}
```
# type Cache
Una caché en memoria para los secretos solicitados a Secrets Manager. Se utiliza [GetSecretString](#retrieving-secrets_cache-go_cache_operations_GetCachedSecret) o [GetSecretBinary](#retrieving-secrets_cache-go_cache_operations_GetSecretBinary) para recuperar un secreto de la caché.
En el siguiente ejemplo se muestra cómo configurar los ajustes de la caché.
```
// Create a custom secretsmanager client
client := getCustomClient()
// Create a custom CacheConfig struct
config := secretcache. CacheConfig{
MaxCacheSize: secretcache.DefaultMaxCacheSize + 10,
VersionStage: secretcache.DefaultVersionStage,
CacheItemTTL: secretcache.DefaultCacheItemTTL,
}
// Instantiate the cache
cache, _ := secretcache.New(
func( c *secretcache.Cache) { c. CacheConfig = config },
func( c *secretcache.Cache) { c. Client = client },
)
```
Para obtener más información, incluidos ejemplos, consulte [Obtener un valor secreto de Secrets Manager mediante Go con almacenamiento en caché del cliente](retrieving-secrets_cache-go.md).
## Métodos
### New
`func New(optFns ...func(*Cache)) (*Cache, error)`
New crea una caché del secreto mediante una serie de opciones funcionales; en caso contrario, utiliza los valores predeterminados. Inicializa un SecretsManager cliente a partir de una nueva sesión. Se inicializa CacheConfig con los valores predeterminados. Inicializa la caché LRU con un tamaño máximo predeterminado.
### GetSecretString
`func (c *Cache) GetSecretString(secretId string) (string, error)`
GetSecretString obtiene el valor de la cadena secreta de la caché para el identificador secreto dado. Devuelve la cadena del secreto y un error si la operación no pudo llevarse a cabo.
### GetSecretStringWithStage
`func (c *Cache) GetSecretStringWithStage(secretId string, versionStage string) (string, error)`
GetSecretStringWithStage obtiene el valor de la cadena secreta de la caché para el ID secreto y la [etapa de versión determinados](whats-in-a-secret.md#term_version). Devuelve la cadena del secreto y un error si la operación no pudo llevarse a cabo.
### GetSecretBinary
`func (c *Cache) GetSecretBinary(secretId string) ([]byte, error) {`
GetSecretBinary obtiene el valor binario secreto de la caché para el ID secreto dado. Devuelve el valor binario del secreto y un error si la operación no pudo llevarse a cabo.
### GetSecretBinaryWithStage
`func (c *Cache) GetSecretBinaryWithStage(secretId string, versionStage string) ([]byte, error)`
GetSecretBinaryWithStage obtiene el valor binario secreto de la caché para el ID secreto y la [etapa de versión determinados](whats-in-a-secret.md#term_version). Devuelve el valor binario del secreto y un error si la operación no pudo llevarse a cabo.
# escriba CacheConfig
Opciones de configuración de la [caché](retrieving-secrets_cache-go_cache.md), como el tamaño máximo de esta, la [fase de versión](whats-in-a-secret.md#term_version) predeterminada y el período de vida (TTL) de los secretos almacenados en ella.
```
type CacheConfig struct {
// The maximum cache size. The default is 1024 secrets.
MaxCacheSize int
// The TTL of a cache item in nanoseconds. The default is
// 3.6e10^12 ns or 1 hour.
CacheItemTTL int64
// The version of secrets that you want to cache. The default
// is "AWSCURRENT".
VersionStage string
// Used to hook in-memory cache updates.
Hook CacheHook
}
```
# tipo CacheHook
Una interfaz para conectarse a una [caché](retrieving-secrets_cache-go_cache.md) y realizar acciones sobre el secreto almacenado en ella.
## Métodos
### Put
`Put(data interface{}) interface{}`
Prepara el objeto para almacenarlo en la caché.
### Get
`Get(data interface{}) interface{}`
Deriva el objeto a partir del objeto almacenado en caché.
# Obtén un valor secreto de Secrets Manager con el AWS SDK de Go
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
Para aplicaciones Go, utilice el [componente de almacenamiento en caché basado en Go de Secrets Manager](retrieving-secrets_cache-go.md) o llame directamente al SDK con [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue) o [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue).
El siguiente ejemplo de código muestra cómo obtener un valor secreto de Secrets Manager.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
// Use this code snippet in your app.
// If you need more information about configurations or implementing the sample code, visit the AWS docs:
// https://aws.github.io/aws-sdk-go-v2/docs/getting-started/
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
)
func main() {
secretName := "<<{{MySecretName}}>>"
region := "<<{{MyRegionName}}>>"
config, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(region))
if err != nil {
log.Fatal(err)
}
// Create Secrets Manager client
svc := secretsmanager.NewFromConfig(config)
input := &secretsmanager.GetSecretValueInput{
SecretId: aws.String(secretName),
VersionStage: aws.String("AWSCURRENT"), // VersionStage defaults to AWSCURRENT if unspecified
}
result, err := svc.GetSecretValue(context.TODO(), input)
if err != nil {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
log.Fatal(err.Error())
}
// Decrypts secret using the associated KMS key.
var secretString string = *result.SecretString
// Your code goes here.
}
```
# Obtener un valor secreto de Secrets Manager con Rust
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
**Topics**
+ [Obtener un valor secreto de Secrets Manager mediante Rust con almacenamiento en caché del cliente](retrieving-secrets_cache-rust.md)
+ [Obtenga un valor secreto de Secrets Manager con el AWS SDK de Rust](retrieving-secrets-rust-sdk.md)
# Obtener un valor secreto de Secrets Manager mediante Rust con almacenamiento en caché del cliente
Cuando recupera un secreto, puede utilizar el componente de almacenamiento en caché basado en Rust de Secrets Manager para utilizarlo más adelante. Recuperar un secreto almacenado en la memoria caché es más rápido que recuperarlo desde Secrets Manager. Como llamar a Secrets Manager conlleva un coste APIs, el uso de una memoria caché puede reducir los costes. Para conocer todas las formas en las que puede recuperar secretos, consulte [Obtener secretos](retrieving-secrets.md).
La caché sigue la política de primero en entrar, primero en salir (FIFO), por lo que cada vez que la caché tiene que descartar un secreto, descarta el más antiguo. De forma predeterminada, la caché actualiza secretos cada hora. Puede configurar las siguientes opciones:
+ `max_size`: el número máximo de secretos en caché que se deben mantener antes de desalojar los secretos a los que no se ha accedido recientemente.
+ `ttl`: el tiempo que se considera válido un elemento almacenado en caché antes de requerir una actualización del estado del secreto.
La implementación de la memoria caché no incluye la invalidación de la memoria caché. La implementación de la memoria caché se centra en la memoria caché en sí misma y no está reforzada ni centrada en la seguridad. Si necesita más seguridad, como cifrar elementos en la memoria caché, utilice los rasgos proporcionados para modificar la caché.
Para utilizar el componente, debe disponer de un entorno de desarrollo Rust 2021 con `tokio`. Para obtener más información, consulte [Comenzar](https://www.rust-lang.org/learn/get-started) en el sitio web del lenguaje de programación Rust.
Para descargar el código fuente, consulte el [componente de cliente de almacenamiento en caché basado en Rust de Secrets Manager](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) en. GitHub
Para instalar el componente de almacenamiento en caché, utilice el siguiente comando.
```
cargo add aws_secretsmanager_caching
```
**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información, consulte [Referencia de permisos](auth-and-access.md#reference_iam-permissions).
**Example Recuperación de un secreto**
En el siguiente ejemplo se muestra cómo obtener el valor secreto de un secreto denominado. *MyTest*
```
use aws_secretsmanager_caching::SecretsManagerCachingClient;
use std::num::NonZeroUsize;
use std::time::Duration;
let client = match SecretsManagerCachingClient::default(
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = match client.get_secret_value("MyTest", None, None).await {
Ok(s) => s.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
**Example Creación de instancias de caché con una configuración y un cliente personalizados**
En el siguiente ejemplo se muestra cómo configurar la caché y, a continuación, obtener el valor secreto de un secreto denominado*MyTest*.
```
let config = aws_config::load_defaults(BehaviorVersion::latest())
.await
.into_builder()
.region(Region::from_static("us-west-2"))
.build();
let asm_builder = aws_sdk_secretsmanager::config::Builder::from(&config);
let client = match SecretsManagerCachingClient::from_builder(
asm_builder,
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = client
.get_secret_value("MyTest", None, None)
.await
{
Ok(c) => c.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
```
# Obtenga un valor secreto de Secrets Manager con el AWS SDK de Rust
En las aplicaciones, puedes recuperar tus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
Para las aplicaciones de Rust, utilice el [componente de almacenamiento en caché basado en Rust de Secrets Manager](retrieving-secrets_cache-rust.md) o llame al [SDK directamente](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) con GetSecretValue o. BatchGetSecretValue
El siguiente ejemplo de código muestra cómo obtener un valor secreto de Secrets Manager.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
async fn show_secret(client: &Client, name: &str) -> Result<(), Error> {
let resp = client.get_secret_value().secret_id(name).send().await?;
println!("Value: {}", resp.secret_string().unwrap_or("No value!"));
Ok(())
}
```
# AWS Secrets Manager Secretos de uso en Amazon Elastic Kubernetes Service
Para mostrar los secretos de AWS Secrets Manager (ASCP) como archivos montados en los pods de Amazon EKS, puede utilizar el proveedor de AWS secretos y configuración del controlador CSI de Kubernetes Secrets Store. El ASCP funciona con Amazon Elastic Kubernetes Service 1.17\$1 y ejecuta un grupo de nodos de Amazon EC2. AWS Fargate no se admiten grupos de nodos. Con el ASCP, puede almacenar y administrar sus secretos en Secrets Manager y recuperarlos a través de sus cargas de trabajo que se ejecutan en Amazon EKS. Si su secreto contiene varios pares clave-valor en formato JSON, puede elegir cuáles montar en Amazon EKS. El ASCP utiliza sintaxis JMESPath para consultar los pares clave-valor en el secreto. El ASCP también funciona con parámetros del almacén de parámetros. El ASCP ofrece dos métodos de autenticación con Amazon EKS. El primer enfoque utiliza los roles de IAM para cuentas de servicio (IRSA). El segundo enfoque utiliza Pod Identities. Cada enfoque tiene sus beneficios y sus casos de uso.
## ASCP con roles de IAM para cuentas de servicio (IRSA)
El ASCP con funciones de IAM para cuentas de servicio (IRSA) le permite montar datos secretos a AWS Secrets Manager partir de archivos en sus Amazon EKS Pods. Este enfoque es adecuado en los siguientes casos:
+ Si desea montar los secretos como archivos en los pods.
+ si está utilizando la versión 1.17 o una posterior de Amazon EKS con grupos de nodos de Amazon EC2,
+ Si desea recuperar pares clave-valor específicos de secretos con formato JSON.
Para obtener más información, consulte [Utilice el CSI del proveedor de AWS secretos y configuración con funciones de IAM para cuentas de servicio (IRSA)](integrating_ascp_irsa.md).
## ASCP con Pod Identity
El método del ASCP con Pod Identity mejora la seguridad y simplifica la configuración para acceder a los secretos en Amazon EKS. Este enfoque resulta beneficioso en los siguientes casos:
+ cuando necesita una administración de permisos más detallada a nivel de pod,
+ si está utilizando la versión 1.24 o una posterior de Amazon EKS,
+ si desea mejorar el rendimiento y la escalabilidad.
Para obtener más información, consulte [Utilice el CSI del proveedor de AWS secretos y configuración con Pod Identity para Amazon EKS](ascp-pod-identity-integration.md).
## Cómo elegir el enfoque correcto
Tenga en cuenta los siguientes factores al decidir entre el ASCP con IRSA y el ASCP con Pod Identity:
+ Amazon EKSversion: Pod Identity requiere Amazon EKS 1.24\$1, mientras que el controlador CSI funciona con Amazon EKS 1.17\$1.
+ Requisitos de seguridad: Pod Identity ofrece un control más detallado a nivel de pod.
+ Rendimiento: por lo general, Pod Identity funciona mejor en entornos de gran escala.
+ Complejidad: Pod Identity simplifica la configuración al eliminar la necesidad de tener cuentas de servicio independientes.
Elija el método que mejor se adapte a sus requisitos específicos y al entorno de Amazon EKS.
# Cómo instalar ASCP para Amazon EKS
En esta sección se explica cómo instalar el proveedor de AWS secretos y configuración para Amazon EKS. Con ASCP, puede montar los secretos de Secrets Manager y los parámetros desde AWS Systems Manager archivos en Amazon EKS Pods.
## Requisitos previos
+ Un clúster de Amazon EKS
+ Versión 1.24 o posterior de Pod Identity
+ Versión 1.17 o posterior de IRSA
+ Los AWS CLI instalados y configurados
+ Kubectl debe estar instalado y configurado para su clúster de Amazon EKS
+ Helm (versión 3.0 o posterior)
## Cómo instalar y configurar el ASCP
El ASCP está disponible GitHub en el repositorio [secrets-store-csi-provider-aws](https://github.com/aws/secrets-store-csi-driver-provider-aws). El repositorio también contiene archivos YAML de ejemplo para crear y montar un secreto.
Durante la instalación, puede configurar el ASCP para que utilice un punto de conexión FIPS. Para obtener una lista de puntos de enlace , consulte [AWS Secrets Manager puntos finales](asm_access.md#endpoints).
**Para instalar el ASCP como un complemento de EKS**
1. Instalar `eksctl` ([instrucciones de instalación](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html))
1. Ejecute el siguiente comando para instalar el complemento con la [configuración predeterminada](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/charts/secrets-store-csi-driver-provider-aws/values.yaml):
```
eksctl create addon --cluster --name aws-secrets-store-csi-driver-provider
```
Si quieres configurar el complemento, ejecuta el siguiente comando de instalación en su lugar:
```
aws eks create-addon --cluster-name --addon-name aws-secrets-store-csi-driver-provider --configuration-values 'file://path/to/config.yaml'
```
El archivo de configuración puede ser un archivo YAML o JSON. Para ver el esquema de configuración del complemento:
1. Ejecute el siguiente comando y anote la última versión del complemento:
```
aws eks describe-addon-versions --addon-name aws-secrets-store-csi-driver-provider
```
1. Ejecuta el siguiente comando para ver el esquema de configuración del complemento y `` sustituirlo por la versión del paso anterior:
```
aws eks describe-addon-configuration --addon-name aws-secrets-store-csi-driver-provider --addon-version
```
**Cómo instalar el ASCP mediante Helm**
1. Para asegurarse de que el repositorio apunte al gráfico más reciente, utilice `helm repo update.`.
1. Instale el gráfico. A continuación, se muestra un ejemplo del comando `helm install`:
```
helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws
```
1. Para utilizar un punto de conexión FIPS, agregue el siguiente indicador: `--set useFipsEndpoint=true`.
1. Para configurar la limitación, agregue el siguiente indicador: `--set-json 'k8sThrottlingParams={"qps": "number of queries per second", "burst": "number of queries per second"}'`.
1. Si el controlador CSI del almacén de secretos ya está instalado en su clúster, agregue el siguiente indicador: `--set secrets-store-csi-driver.install=false`. Esto omitirá la instalación del controlador CSI del almacén de secretos como dependencia.
**Cómo instalarlo mediante el YAML del repositorio**
+ Use los siguientes comandos.
```
helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts
helm install -n kube-system csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/deployment/aws-provider-installer.yaml
```
## Cómo verificar las instalaciones
Para verificar las instalaciones del clúster de EKS, el controlador CSI de Secrets Store y el complemento ASCP, siga estos pasos:
1. Verifique el clúster de EKS:
```
eksctl get cluster --name clusterName
```
Este comando debería devolver información sobre el clúster.
1. Verifique la instalación del controlador CSI de Secrets Store:
```
kubectl get pods -n kube-system -l app=secrets-store-csi-driver
```
Debería ver los pods en ejecución con nombres como `csi-secrets-store-secrets-store-csi-driver-xxx`.
1. Verifique la instalación del complemento ASCP:
------
#### [ YAML installation ]
```
$ kubectl get pods -n kube-system -l app=csi-secrets-store-provider-aws
```
Ejemplo de código de salida:
```
NAME READY STATUS RESTARTS AGE
csi-secrets-store-provider-aws-12345 1/1 Running 0 2m
```
------
#### [ Helm installation ]
```
$ kubectl get pods -n kube-system -l app=secrets-store-csi-driver-provider-aws
```
Ejemplo de código de salida:
```
NAME READY STATUS RESTARTS AGE
secrets-provider-aws-secrets-store-csi-driver-provider-67890 1/1 Running 0 2m
```
------
Debería ver los pods con el estado `Running`.
Después de ejecutar estos comandos, si todo está configurado correctamente, debería ver que todos los componentes se están ejecutando sin errores. Si encuentra algún problema, es posible que deba consultar los registros de los pods que contienen dicho problema para solucionarlo.
## Resolución de problemas
1. Para verificar los registros del proveedor del ASCP, ejecute:
```
kubectl logs -n kube-system -l app=csi-secrets-store-provider-aws
```
1. Verifique el estado de todos los pods en el espacio de nombres `kube-system`:
```
kubectl -n kube-system get pods
```
```
kubectl -n kube-system logs pod/PODID
```
Todos los pods relacionados con el controlador CSI y el ASCP deben tener el estado “En ejecución”.
1. Verifique la versión del controlador CSI:
```
kubectl get csidriver secrets-store.csi.k8s.io -o yaml
```
Este comando debería devolver información sobre el controlador CSI instalado.
## Recursos adicionales
Para obtener más información sobre el uso del ASCP con Amazon EKS, consulte los siguientes recursos:
+ [Using Pod Identity with Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [AWS Secrets Store CSI está activado GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Utilice el CSI del proveedor de AWS secretos y configuración con Pod Identity para Amazon EKS
La integración del proveedor de AWS secretos y configuración con el agente de identidad del pod para Amazon Elastic Kubernetes Service proporciona una seguridad mejorada, una configuración simplificada y un rendimiento mejorado para las aplicaciones que se ejecutan en Amazon EKS. Pod Identity simplifica la autenticación de IAM para Amazon EKS al recuperar secretos de Secrets Manager o parámetros de Parameter Store AWS Systems Manager .
Pod Identity de Amazon EKS agiliza el proceso de configuración de los permisos de IAM para las aplicaciones de Kubernetes, ya que permite que los permisos se configuren directamente a través de las interfaces de Amazon EKS, lo que reduce el número de pasos y elimina la necesidad de cambiar entre los servicios de Amazon EKS e IAM. Pod Identity permite usar un solo rol de IAM en varios clústeres sin actualizar las políticas de confianza y admite [etiquetas de sesión de rol](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags) para un control de acceso más detallado. Este enfoque no solo simplifica la administración de políticas al permitir la reutilización de las políticas de permisos en todas las funciones, sino que también mejora la seguridad al permitir el acceso a AWS los recursos en función de las etiquetas coincidentes.
## Funcionamiento
1. Pod Identity asigna un rol de IAM al pod.
1. ASCP usa esta función para autenticarse con. Servicios de AWS
1. Si está autorizado, ASCP recupera los secretos solicitados y hace que estén disponibles para el pod.
Para obtener más información, consulte [Descripción del funcionamiento de Pod Identity de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html) en la *Guía del usuario de Amazon EKS*.
## Requisitos previos
**importante**
Pod Identity solo es compatible con Amazon EKS en la nube. No es compatible con [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/), [Red Hat OpenShift Service en AWS](https://aws.amazon.com/rosa/) ni con los clústeres de Kubernetes autoadministrados en las instancias de Amazon EC2.
+ Clúster de Amazon EKS (versión 1.24 o posterior)
+ Acceso a un clúster AWS CLI de Amazon EKS a través de `kubectl`
+ Acceso a dos Cuentas de AWS (para acceso entre cuentas)
## Cómo instalar el agente de Pod Identity de Amazon EKS
Para usar Pod Identity con el clúster, debe instalar el complemento del agente de Pod Identity de Amazon EKS.
**Cómo instalar el agente de Pod Identity**
+ Instale el complemento del agente de Pod Identity en el clúster:
```
eksctl create addon \
--name eks-pod-identity-agent \
--cluster clusterName \
--region region
```
## Cómo configurar el ASCP con Pod Identity
1. Cree una política de permisos que conceda los permisos `secretsmanager:GetSecretValue` y `secretsmanager:DescribeSecret` a los secretos que el pod necesita acceder. Para ver una política de ejemplo, consulte [Ejemplo: Permiso para leer y describir secretos individuales](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Cree un rol de IAM que pueda ser asumido por la entidad principal de servicio de Amazon EKS para Pod Identity:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
Adjunte la política de IAM al rol:
```
aws iam attach-role-policy \
--role-name MY_ROLE \
--policy-arn POLICY_ARN
```
1. Cree una asociación de Pod Identity. Para ver un ejemplo, consulte [Creación de una asociación de Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create) en la *Guía del usuario de Amazon EKS*.
1. Cree `SecretProviderClass` que especifica qué secretos se deben montar en el pod:
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleSecretProviderClass-PodIdentity.yaml
```
La diferencia clave en `SecretProviderClass` entre los roles de IAM para las cuentas de servicio (IRSA) y Pod Identity es el parámetro opcional `usePodIdentity`. Es un campo opcional que determina el enfoque de autenticación. Si no se especifica, se utilizarán los roles de IAM para IRSA de manera predeterminada.
+ Para usar Pod Identity de EKS, utilice cualquiera de estos valores: `"true", "True", "TRUE", "t", "T"`.
+ Para usar IRSA de forma explícita, establézcalo en cualquiera de estos valores: `"false", "False", "FALSE", "f", or "F"`.
1. Implemente el pod que monta los secretos en `/mnt/secrets-store`:
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml
```
1. Si utiliza un clúster privado de Amazon EKS, asegúrese de que la VPC en la que se encuentra el clúster tenga un AWS STS punto de conexión. Para obtener más información sobre la creación de un punto de conexión, consulte [Puntos de conexión de VPC de tipo interfaz](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) en la *Guía del usuario de AWS Identity and Access Management *.
### Cómo verificar el montaje del secreto
Para verificar que el secreto se ha montado correctamente, ejecute el siguiente comando:
```
kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MySecret
```
**Cómo configurar al Pod Identity de Amazon EKS para acceder a los secretos de Secrets Manager**
1. Cree una política de permisos que conceda los permisos `secretsmanager:GetSecretValue` y `secretsmanager:DescribeSecret` a los secretos que el pod necesita acceder. Para ver una política de ejemplo, consulte [Ejemplo: Permiso para leer y describir secretos individuales](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. En caso de no disponer de un secreto en Secrets Manager, debe crear uno.
## Solución de problemas
Puede ver la mayoría de los errores si describe la implementación del pod.
**Cómo ver los mensajes de error del contenedor**
1. Obtenga una lista de nombres de pods con el siguiente comando. Si no está utilizando el espacio de nombres predeterminado, use `-n NAMESPACE`.
```
kubectl get pods
```
1. Para describir el pod, en el siguiente comando, *PODID* usa el ID de pod de los pods que encontraste en el paso anterior. Si no está utilizando el espacio de nombres predeterminado, use `-n NAMESPACE`.
```
kubectl describe pod/PODID
```
**Cómo ver los errores del ASCP**
+ Para obtener más información en los registros del proveedor, usa el siguiente comando para *PODID* usar el ID del pod *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs pod/PODID
```
# Utilice el CSI del proveedor de AWS secretos y configuración con funciones de IAM para cuentas de servicio (IRSA)
**Topics**
+ [Requisitos previos](#prerequisites)
+ [Cómo configurar el control de acceso](#integrating_ascp_irsa_access)
+ [Identificar qué secretos hay que montar](#integrating_ascp_irsa_mount)
+ [Solución de problemas](#integrating_ascp_irsa_trouble)
## Requisitos previos
+ Clúster de Amazon EKS (versión 1.17 o posterior)
+ Acceso a un clúster AWS CLI de Amazon EKS a través de `kubectl`
## Cómo configurar el control de acceso
El ASCP recupera Pod Identity de Amazon EKS y la cambia por un rol de IAM. Los permisos se establecen en una política de IAM para ese rol de IAM. Cuando el ASCP asume el rol de IAM, le da acceso a los secretos autorizados por usted. Otros contenedores no pueden acceder a los secretos a menos que también los asocie con el rol de IAM.
**Cómo concederle al pod de Amazon EKS acceso a los secretos de Secrets Manager**
1. Cree una política de permisos que conceda los permisos `secretsmanager:GetSecretValue` y `secretsmanager:DescribeSecret` a los secretos que el pod necesita acceder. Para ver una política de ejemplo, consulte [Ejemplo: Permiso para leer y describir secretos individuales](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Cree un proveedor OpenID Connect (OIDC) de IAM para el clúster si todavía no tiene uno. Para obtener más información, consulte [Crear un proveedor OIDC de IAM para su clúster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) en la *Guía del usuario de Amazon EKS*.
1. Cree un [rol de IAM para la cuenta de servicio](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) y adjunte la política. Para obtener más información, consulte [Crear un rol de IAM para su cuenta de servicio](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) en la *Guía del usuario de Amazon EKS*.
1. Si utiliza un clúster privado de Amazon EKS, asegúrese de que la VPC en la que se encuentra el clúster tenga un AWS STS punto de conexión. Para obtener más información sobre la creación de un punto de conexión, consulte [Puntos de conexión de VPC de tipo interfaz](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) en la *Guía del usuario de AWS Identity and Access Management *.
## Identificar qué secretos hay que montar
Para determinar qué secretos debe montar el ASCP en Amazon EKS como archivos del sistema de archivos, se debe crear un archivo YAML [SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass). El `SecretProviderClass` contiene una lista de los secretos que hay que montar y el nombre de archivo con el que montarlos. El `SecretProviderClass` debe estar en el mismo espacio de nombres que el pod de Amazon EKS al que hace referencia.
### Montar los secretos como archivos
[Las siguientes instrucciones muestran cómo montar secretos como archivos utilizando los archivos YAML de ejemplo .yaml y [ExampleSecretProviderClass.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml). ExampleDeployment](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleDeployment-IRSA.yaml)
**Montar secretos en Amazon EKS**
1. Aplique el `SecretProviderClass` al pod:
```
kubectl apply -f ExampleSecretProviderClass.yaml
```
1. Implemente el pod:
```
kubectl apply -f ExampleDeployment.yaml
```
1. El ASCP monta los archivos.
## Solución de problemas
Puede ver la mayoría de los errores si describe la implementación del pod.
**Cómo ver los mensajes de error del contenedor**
1. Obtenga una lista de nombres de pods con el siguiente comando. Si no está utilizando el espacio de nombres predeterminado, use `-n nameSpace`.
```
kubectl get pods
```
1. Para describir el pod, en el siguiente comando, *podId* usa el ID de pod de los pods que encontraste en el paso anterior. Si no está utilizando el espacio de nombres predeterminado, use `-n nameSpace`.
```
kubectl describe pod/podId
```
**Cómo ver los errores del ASCP**
+ Para obtener más información en los registros del proveedor, usa el siguiente comando para *podId* usar el ID del pod *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs Pod/podId
```
+
**Cómo comprobar que la definición de recurso personalizado (CRD) de `SecretProviderClass` está instalada:**
```
kubectl get crd secretproviderclasses.secrets-store.csi.x-k8s.io
```
Este comando debe devolver información acerca de la definición de recurso personalizado de `SecretProviderClass`.
+
**Compruebe que se haya creado el SecretProviderClass objeto.**
```
kubectl get secretproviderclass SecretProviderClassName -o yaml
```
# AWS Ejemplos de código de proveedores de secretos y configuraciones
## Ejemplos de autenticación y control de acceso del ASCP
### Ejemplo: política de IAM que permite que el servicio Pod Identity de Amazon EKS (pods.eks.amazonaws.com) asuma el rol y etiquete la sesión:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
## SecretProviderClass
Se debe utilizar YAML para describir qué secretos hay que montar en Amazon EKS mediante el ASCP. Para ver ejemplos, consulte [SecretProviderClass uso](#ascp-scenarios-secretproviderclass).
### SecretProviderClass Estructura YAML
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: name
spec:
provider: aws
parameters:
region:
failoverRegion:
pathTranslation:
usePodIdentity:
preferredAddressType:
objects:
```
Los campos de los parámetros contienen los detalles de la solicitud de montaje:
**region**
(Opcional) El Región de AWS del secreto. Si no utiliza este campo, el ASCP busca la región en la anotación en el nodo. Esta búsqueda agrega una sobrecarga a las solicitudes de montaje, por lo que recomendamos que proporcione la región para los clústeres que utilizan una gran cantidad de pods.
Si también se especifica `failoverRegion`, el ASCP intenta recuperar el secreto desde ambas regiones. Si alguna de estas regiones devuelve un error 4xx, por ejemplo por un problema de autenticación, el ASCP no monta ninguno de los secretos. Si el secreto se recupera correctamente desde `region`, el ASCP monta ese valor de secreto. Si el secreto no se recupera correctamente desde `region`, pero sí desde `failoverRegion`, el ASCP monta ese valor de secreto.
**failoverRegion**
(Opcional) Si se incluye este campo, la ASCP intenta recuperar el secreto desde las regiones definidas en `region` y este campo. Si alguna de estas regiones devuelve un error 4xx, por ejemplo por un problema de autenticación, el ASCP no monta ninguno de los secretos. Si el secreto se recupera correctamente desde `region`, el ASCP monta ese valor de secreto. Si el secreto no se recupera correctamente desde `region`, pero sí desde `failoverRegion`, el ASCP monta ese valor de secreto. Para ver un ejemplo sobre cómo utilizar este campo, consulte [Conmutación por error de varias regiones](#multi-region-failover).
**pathTranslation**
(Opcional) Un único carácter de sustitución para utilizarlo si el nombre del archivo de Amazon EKS contiene el carácter separador de ruta, por ejemplo la barra diagonal (/) en Linux. El ASCP no puede crear un archivo montado que contenga un carácter separador de ruta. En su lugar, el ASCP reemplaza el carácter separador de ruta por otro carácter. Si no se utiliza este campo, el carácter de reemplazo es el guion bajo (\$1), de modo que, por ejemplo, `My/Path/Secret` se monta como `My_Path_Secret`.
Para evitar la sustitución de caracteres, ingrese la cadena `False`.
**usePodIdentity**
(Opcional) Determine el enfoque de autenticación. Si no se especifica, se utilizarán los roles de IAM para las cuentas de servicio (IRSA) de manera predeterminada.
+ Para usar Pod Identity de EKS, utilice cualquiera de estos valores: `"true"`, `"True"`, `"TRUE"`, `"t"` o `"T"`.
+ Para usar IRSA de forma explícita, establezca cualquiera de estos valores: `"false"`, `"False"`, `"FALSE"`, `"f"` o `"F"`.
**preferredAddressType**
(Opcional) Especifica el tipo de dirección IP preferido para la comunicación del punto de conexión del agente de Pod Identity. El campo solo se aplica cuando se utiliza la característica Pod Identity de EKS y se ignora cuando se utilizan roles de IAM para cuentas de servicio. Los valores no distinguen entre mayúsculas y minúsculas. Los valores válidos son:
+ `"ipv4"`, `"IPv4"` «o `"IPV4"` — Forzar el uso del IPv4 terminal Pod Identity Agent
+ `"ipv6"`,`"IPv6"`, o `"IPV6"` — Forzar el uso del IPv6 punto final del Pod Identity Agent
+ no especificado: utilice la selección automática del punto final, pruebe primero el IPv4 punto final y vuelva al IPv6 punto final si IPv4 falla
**objetos**
Una cadena que contiene una declaración YAML de los secretos que se van a montar. Se recomienda utilizar una cadena de varias líneas de YAML o una barra vertical (\$1).
**objectName**
Obligatorio. Especifica el nombre del secreto o parámetro que se va a obtener. En el caso de Secrets Manager, este es el parámetro [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters) y puede ser el nombre descriptivo o el ARN completo del secreto. En el caso de SSM Parameter Store, este es el [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters) del parámetro y puede ser el nombre o el ARN completo del parámetro.
**objectType**
Es requerido si no utiliza un ARN de Secrets Manager para `objectName`. Puede ser `secretsmanager` o `ssmparameter`.
**objectAlias**
(Opcional) El nombre de archivo del secreto en el pod de Amazon EKS. Si no especifica este campo, el `objectName` aparece como nombre de archivo.
**filePermission**
(Opcional) Cadena octal de 4 dígitos que especifica el permiso de archivo con el que se debe montar el secreto. Si no especifica este campo, se aplicará un valor predeterminado de `"0644"`.
**objectVersion**
(Opcional) El ID de versión del secreto. No se recomienda, porque se debe actualizar el ID de versión cada vez que se actualice el secreto. Se utiliza la versión más reciente de forma predeterminada. Si se incluye `failoverRegion`, este campo representa el campo `objectVersion` principal.
**objectVersionLabel**
(Opcional) El alias de la versión. La versión predeterminada es la versión AWSCURRENT más reciente. Para obtener más información, consulte [Versiones de un secreto](whats-in-a-secret.md#term_version). Si se incluye `failoverRegion`, este campo representa el campo `objectVersionLabel` principal.
**jmesPath**
(Opcional) Un mapa de las claves en el secreto a los archivos que se van a montar en Amazon EKS. Para utilizar este campo, el valor secreto debe estar en formato JSON. Si utiliza este campo, debe incluir los subcampos `path` y `objectAlias`.
**path**
Una clave de un par clave-valor en el JSON del valor secreto. Si el campo contiene un guion, aplique escape con comillas simples, por ejemplo: `path: '"hyphenated-path"'`
**objectAlias**
Nombre de archivo que se va a montar en el pod de Amazon EKS. Si el campo contiene un guion, aplique escape con comillas simples, por ejemplo: `objectAlias: '"hyphenated-alias"'`
**filePermission**
(Opcional) Cadena octal de 4 dígitos que especifica el permiso de archivo con el que se debe montar el secreto. Si no especifica este campo, se utilizará por defecto el permiso de archivo del objeto principal.
**failoverObject**
(Opcional) Si se especifica este campo, el ASCP intenta recuperar tanto el secreto especificado en el campo `objectName` principal como el secreto especificado en el subcampo `failoverObject` `objectName`. Si alguno devuelve un error 4xx, por ejemplo por un problema de autenticación, el ASCP no monta ninguno de los secretos. Si el secreto se recupera correctamente desde el campo `objectName` principal, el ASCP monta ese valor de secreto. Si el secreto no se recupera correctamente desde el campo `objectName` principal, pero sí desde el `objectName` de conmutación por error, el ASCP monta ese valor de secreto. Si se incluye este campo, se debe incluir el campo `objectAlias`. Para ver un ejemplo sobre cómo utilizar este campo, consulte [Conmutación por error a un secreto diferente](#failover-secret).
Este campo se suele utilizar cuando el secreto de conmutación por error no es una réplica. Para ver un ejemplo sobre cómo especificar una réplica, consulte [Conmutación por error de varias regiones](#multi-region-failover).
**objectName**
Nombre o ARN completo del secreto de conmutación por error. Si se utiliza un ARN, la región del ARN debe coincidir con el campo `failoverRegion`.
**objectVersion**
(Opcional) El ID de versión del secreto. Debe coincidir con el campo `objectVersion` principal. No se recomienda, porque se debe actualizar el ID de versión cada vez que se actualice el secreto. Se utiliza la versión más reciente de forma predeterminada.
**objectVersionLabel**
(Opcional) El alias de la versión. La versión predeterminada es la más reciente AWSCURRENT. Para obtener más información, consulte [Versiones de un secreto](whats-in-a-secret.md#term_version).
### Crea una SecretProviderClass configuración básica para montar secretos en tus Amazon EKS Pods.
------
#### [ Pod Identity ]
SecretProviderClass para usar un secreto en el mismo clúster de Amazon EKS:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets-manager
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
usePodIdentity: "true"
```
------
#### [ IRSA ]
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: deployment-aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "MySecret"
objectType: "secretsmanager"
```
------
### SecretProviderClass uso
Utilice estos ejemplos para crear SecretProviderClass configuraciones para diferentes escenarios.
#### Ejemplo: Montar secretos por nombre o ARN
En este ejemplo, se muestra cómo montar tres tipos diferentes de secretos:
+ Un secreto especificado por ARN completo
+ Un secreto especificado por nombre
+ Una versión específica de un secreto
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret2-d4e5f6"
- objectName: "MySecret3"
objectType: "secretsmanager"
- objectName: "MySecret4"
objectType: "secretsmanager"
objectVersionLabel: "AWSCURRENT"
```
#### Ejemplo: montar pares clave/valor de un secreto
En este ejemplo, se muestra cómo montar pares clave-valor específicos a partir de un secreto con formato JSON:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret-a1b2c3"
jmesPath:
- path: username
objectAlias: dbusername
- path: password
objectAlias: dbpassword
```
#### Ejemplo: montar secretos mediante permiso de archivo
En este ejemplo, se muestra cómo montar un secreto con un permiso de archivo específico
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
filePermission: "0600"
jmesPath:
- path: username
objectAlias: dbusername
filePermission: "0400"
```
#### Ejemplo: configuración de conmutación por error
En estos ejemplos, se muestra cómo configurar la conmutación por error para secretos.
##### Conmutación por error de varias regiones
En este ejemplo, se muestra cómo configurar la conmutación por error automática para un secreto replicado en varias regiones:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "MySecret"
```
##### Conmutación por error a un secreto diferente
En este ejemplo, se muestra cómo configurar la conmutación por error a un secreto diferente (no a una réplica):
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "arn:aws:secretsmanager:us-east-1:777788889999:secret:MySecret-a1b2c3"
objectAlias: "MyMountedSecret"
failoverObject:
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MyFailoverSecret-d4e5f6"
```
## Recursos adicionales
Para obtener más información sobre el uso del ASCP con Amazon EKS, consulte los siguientes recursos:
+ [Using Pod Identity with Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [Uso del proveedor de AWS secretos y configuraciones](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_csi.html)
+ [AWS Secrets Store CSI está activado GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Usa AWS Secrets Manager secretos en AWS Lambda las funciones
AWS Lambda es un servicio de computación sin servidor que permite ejecutar código sin aprovisionar ni administrar servidores. Parameter Store, una capacidad de AWS Systems Manager, proporciona un almacenamiento jerárquico y seguro para la gestión de los datos de configuración y la gestión de secretos. Puede usar la extensión Lambda AWS Parameters and Secrets para recuperar y almacenar en caché AWS Secrets Manager los secretos y los parámetros del almacén de parámetros en las funciones de Lambda sin usar un SDK. Para obtener información detallada sobre el uso de esta extensión, consulte [Uso de los secretos de Secrets Manager en las funciones de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html) en la *Guía para desarrolladores de Lambda*.
## Uso de los secretos de Secrets Manager con Lambda
La guía para desarrolladores de Lambda brinda instrucciones completas para utilizar los secretos de Secrets Manager en las funciones de Lambda. Primeros pasos:
1. Siga el step-by-step tutorial de los [secretos de Use Secrets Manager en las funciones de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html), que incluye:
+ Creación de una función de Lambda con el tiempo de ejecución preferido (Python, Node.js, Java)
+ Añadir la Extensión Lambda de AWS Parámetros y Secretos como una capa
+ Configuración de los permisos necesarios
+ Escritura del código para recuperar los secretos de la extensión
+ Comprobación de la función
1. Obtenga información sobre las variables de entorno para configurar el comportamiento de la extensión, como la configuración de la caché y los tiempos de espera
1. Descubra las prácticas recomendadas para trabajar con la rotación de secretos
### Uso de Secrets Manager y Lambda en una VPC
Si su función de Lambda se ejecuta en una VPC, debe crear un punto de conexión de VPC para que la extensión pueda realizar llamadas a Secrets Manager. Para obtener más información, consulte [Uso de un punto final AWS Secrets Manager de VPC](vpc-endpoint-overview.md).
## Uso de la AWS extensión Lambda Parameters and Secrets
La extensión puede recuperar los secretos de Secrets Manager y los parámetros del almacén de parámetros. Para obtener información detallada sobre el uso de los parámetros de Parameter Store con la extensión, consulte [Uso de los parámetros de Parameter Store en las funciones de Lambda](https://docs.aws.amazon.com/systems-manager/latest/userguide/ps-integration-lambda-extensions.html) en la *Guía del usuario de AWS Systems Manager *.
La documentación de Systems Manager incluye:
+ Explicación detallada de cómo funciona la extensión con Parameter Store
+ Instrucciones para agregar la extensión a una función de Lambda
+ Variables de entorno para configurar la extensión
+ Ejemplos de comandos para recuperar parámetros
+ Lista completa de extensiones ARNs para todas las arquitecturas y regiones compatibles
# Uso del AWS Secrets Manager agente
## Cómo funciona el Agente de Secrets Manager
El AWS Secrets Manager agente es un servicio HTTP del lado del cliente que le ayuda a estandarizar la forma en que consume los secretos de Secrets Manager en todos sus entornos de cómputo. Puede utilizarlo con los siguientes servicios:
+ AWS Lambda
+ Amazon Elastic Container Service
+ Amazon Elastic Kubernetes Service
+ Amazon Elastic Compute Cloud
El Agente de Secrets Manager recupera y almacena en caché los secretos en la memoria, lo que permite que las aplicaciones obtengan secretos de localhost en lugar de tener que hacer llamadas directas a Secrets Manager. El Agente de Secrets Manager solo puede leer secretos, pero no modificarlos.
**importante**
El agente de Secrets Manager utiliza las AWS credenciales de su entorno para llamar a Secrets Manager. Incluye protección contra la falsificación de solicitudes del lado del servidor (SSRF) para ayudar a mejorar la seguridad del secreto. El Agente de Secrets Manager, por defecto, utiliza el intercambio de claves ML-KEM poscuántico como el intercambio de claves de mayor prioridad..
## Comprensión del almacenamiento en caché del Agente de Secrets Manager
El Agente de Secrets Manager utiliza una caché en memoria que se restablece cuando se reinicia. Regularmente, actualiza los valores de secretos almacenados en caché según lo siguiente:
+ La frecuencia de actualización predeterminada (TTL) es de 300 segundos
+ Se puede modificar TTL mediante un archivo de configuración
+ La actualización se produce cuando se solicita un secreto después de que TTL caduque
**nota**
El Agente de Secrets Manager no incluye la invalidación del caché. Si un secreto rota antes de que caduque la entrada del caché, el Agente de Secrets Manager podría devolver un valor secreto obsoleto.
El Agente de Secrets Manager devuelve los valores secretos en el mismo formato que la respuesta de `GetSecretValue`. Los valores de secretos no se cifran en caché.
**Topics**
+ [Cómo funciona el Agente de Secrets Manager](#agent-overview)
+ [Comprensión del almacenamiento en caché del Agente de Secrets Manager](#agent-caching)
+ [Compilación del Agente de Secrets Manager](#secrets-manager-agent-build)
+ [Instale el Agente de Secrets Manager](#secrets-manager-agent-install)
+ [Recuperación de secretos con el Agente de Secrets Manager](#secrets-manager-agent-call)
+ [Comprensión del parámetro `refreshNow`](#secrets-manager-agent-refresh)
+ [Configuración del Agente de Secrets Manager](#secrets-manager-agent-config)
+ [Características opcionales](#secrets-manager-agent-features)
+ [Registro](#secrets-manager-agent-log)
+ [Consideraciones de seguridad](#secrets-manager-agent-security)
## Compilación del Agente de Secrets Manager
Antes de comenzar, asegúrese de tener instaladas las herramientas de desarrollo estándar y las herramientas de Rust en la plataforma.
**nota**
La compilación del agente con la característica `fips` habilitada en macOS requiere la siguiente solución alternativa:
Cree una variable de entorno llamada `SDKROOT` que se establezca según el resultado de la ejecución de `xcrun --show-sdk-path`
------
#### [ RPM-based systems ]
**Cómo compilar sobre sistemas basados en RPM**
1. Use el script de `install` que se proporciona en el repositorio.
El script genera un token SSRF aleatorio al inicio y lo almacena en el archivo`/var/run/awssmatoken`. El grupo `awssmatokenreader` que crea el script de instalación puede leer el token.
1. Para permitir que la aplicación lea el archivo de token, debe añadir, al grupo `awssmatokenreader`, la cuenta de usuario con la que se ejecuta la aplicación. Por ejemplo, puede conceder permisos para que su aplicación lea el archivo de token con el siguiente comando usermod, que ** es el ID de usuario con el que se ejecuta la aplicación.
```
sudo usermod -aG awssmatokenreader
```
**Instale las herramientas de desarrollo**
En sistemas basados en RPM, por ejemplo AL2023, instale el grupo de herramientas de desarrollo:
```
sudo yum -y groupinstall "Development Tools"
```
1.
**Instale Rust**
Siga las instrucciones de [Instalar Rust](https://www.rust-lang.org/tools/install) en la *documentación de Rust*.
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Compile el agente**
Compile el Agente de Secrets Manager mediante el comando cargo build:
```
cargo build --release
```
Encontrará el ejecutable en `target/release/aws_secretsmanager_agent`.
------
#### [ Debian-based systems ]
**Cómo compilar en sistemas basados en Debian**
1.
**Instale las herramientas de desarrollo**
En sistemas basados en Debian, como Ubuntu, instale el paquete build-essential:
```
sudo apt install build-essential
```
1.
**Instale Rust**
Siga las instrucciones de [Instalar Rust](https://www.rust-lang.org/tools/install) en la *documentación de Rust*.
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Compile el agente**
Compile el Agente de Secrets Manager mediante el comando cargo build:
```
cargo build --release
```
Encontrará el ejecutable en `target/release/aws_secretsmanager_agent`.
------
#### [ Windows ]
**Cómo compilar en Windows**
1.
**Establezca un entorno de desarrollo**
Siga las instrucciones de [Configurar el entorno de desarrollo en Windows para Rust](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup) en la *documentación de Microsoft Windows*.
1.
**Compile el agente**
Compile el Agente de Secrets Manager mediante el comando cargo build:
```
cargo build --release
```
Encontrará el ejecutable en `target/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross-compile natively ]
**Cómo compilar de forma cruzada de forma nativa**
1.
**Instale las herramientas de compilación cruzada**
En las distribuciones en las que está disponible el paquete mingw-w64, como Ubuntu, instale la cadena de herramientas de compilaciones cruzadas:
```
# Install the cross compile tool chain
sudo add-apt-repository universe
sudo apt install -y mingw-w64
```
1.
**Agregue los destinos de compilación de Rust**
Instale el destino de compilación para Windows GNU:
```
rustup target add x86_64-pc-windows-gnu
```
1.
**Compile para Windows**
Compile de forma cruzada el agente para Windows:
```
cargo build --release --target x86_64-pc-windows-gnu
```
Encontrará el ejecutable en `target/x86_64-pc-windows-gnu/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross compile with Rust cross ]
**Cómo realizar una compilación cruzada con Rust cross**
Si las herramientas de compilación cruzada no están disponibles de forma nativa en el sistema, puede utilizar el proyecto de Rust cross. [Para obtener más información, consulte https://github.com/cross-rs/ cross.](https://github.com/cross-rs/cross)
**importante**
Recomendamos 32 GB de espacio en disco para el entorno de compilación.
1.
**Configuración de Docker**
Instale y configure Docker
```
# Install and start docker
sudo yum -y install docker
sudo systemctl start docker
sudo systemctl enable docker # Make docker start after reboot
```
1.
**Configure los permisos de Docker**
Agregue su usuario al grupo de Docker
```
# Give ourselves permission to run the docker images without sudo
sudo usermod -aG docker $USER
newgrp docker
```
1.
**Compile para Windows**
Instale cross y compile el ejecutable:
```
# Install cross and cross compile the executable
cargo install cross
cross build --release --target x86_64-pc-windows-gnu
```
------
## Instale el Agente de Secrets Manager
Elija su entorno informático entre las siguientes opciones de instalación.
------
#### [ Amazon EC2 ]
**Cómo instalar el Agente de Secrets Manager en Amazon EC2**
1.
**Diríjase hasta el directorio de configuración**
Cambie al directorio de configuración:
```
cd aws_secretsmanager_agent/configuration
```
1.
**Ejecute el script de instalación**
Utilice el script de `install` que se proporciona en el repositorio.
El script genera un token SSRF aleatorio al inicio y lo almacena en el archivo`/var/run/awssmatoken`. El grupo `awssmatokenreader` que crea el script de instalación puede leer el token.
1.
**Configuración de permisos de aplicación**
Agregue al grupo `awssmatokenreader` la cuenta de usuario con la que se ejecuta la aplicación:
```
sudo usermod -aG awssmatokenreader APP_USER
```
*APP\$1USER*Sustitúyalo por el seudónimo con el que se ejecuta la aplicación.
------
#### [ Container Sidecar ]
Puede ejecutar el Agente de Secrets Manager como un contenedor lateral junto con la aplicación mediante Docker. Luego, su aplicación puede recuperar los secretos del servidor HTTP local que proporciona el Agente de Secrets Manager. Para obtener más información sobre Docker, consulte la[ documentación de Docker](https://docs.docker.com).
**Cómo crear un contenedor lateral para el Agente de Secrets Manager**
1.
**Cree un archivo Dockerfile.**
Cree un Dockerfile para el contenedor lateral del Agente de Secrets Manager:
```
# Use the latest Debian image as the base
FROM debian:latest
# Set the working directory inside the container
WORKDIR /app
# Copy the Secrets Manager Agent binary to the container
COPY secrets-manager-agent .
# Install any necessary dependencies
RUN apt-get update && apt-get install -y ca-certificates
# Set the entry point to run the Secrets Manager Agent binary
ENTRYPOINT ["./secrets-manager-agent"]
```
1.
**Cree Dockerfile de aplicación**
Cree un Dockerfile para su aplicación cliente.
1.
**Cree el archivo Docker Compose**
Cree un archivo Docker Compose para ejecutar ambos contenedores con una interfaz de red compartida:
**importante**
Debe cargar AWS las credenciales y el token de la SSRF para que la aplicación pueda utilizar el agente Secrets Manager. Para Amazon EKS y Amazon ECS, consulte lo siguiente:
[Administrar el acceso](https://docs.aws.amazon.com/eks/latest/userguide/cluster-auth.html) en la *Guía del usuario de Amazon EKS*
[Rol de IAM en las tareas de Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) en la *Guía para desarrolladores de Amazon ECS*
```
version: '3'
services:
client-application:
container_name: client-application
build:
context: .
dockerfile: Dockerfile.client
command: tail -f /dev/null # Keep the container running
secrets-manager-agent:
container_name: secrets-manager-agent
build:
context: .
dockerfile: Dockerfile.agent
network_mode: "container:client-application" # Attach to the client-application container's network
depends_on:
- client-application
```
1.
**Copie el ejecutable del agente**
Copie el binario `secrets-manager-agent` en el mismo directorio que contiene sus archivos Dockerfiles y Docker Compose.
1.
**Compile y ejecute contenedores**
Compile y ejecute los contenedores mediante Docker Compose:
```
docker-compose up --build
```
1.
**Siguientes pasos**
Ahora es posible utilizar el Agente de Secrets Manager para recuperar los secretos desde un contenedor de clientes. Para obtener más información, consulte [Recuperación de secretos con el Agente de Secrets Manager](#secrets-manager-agent-call).
------
#### [ Lambda ]
Puede [empaquetar el Agente de Secrets Manager como una extensión de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html). A continuación, puede [añadirla a la función de Lambda como una capa](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html) y llamar al Agente de Secrets Manager desde la función de Lambda para obtener los secretos.
Las siguientes instrucciones muestran cómo obtener un nombre secreto *MyTest*mediante el script `secrets-manager-agent-extension.sh` de ejemplo [https://github.com/aws/aws-secretsmanager-agent](https://github.com/aws/aws-secretsmanager-agent)para instalar el agente Secrets Manager como una extensión de Lambda.
**Crear una extensión de Lambda para el Agente de Secrets Manager**
1.
**Empaquetar la capa del agente**
Desde la raíz del paquete de códigos del Agente de Secrets Manager, ejecute los siguientes comandos:
```
AWS_ACCOUNT_ID=AWS_ACCOUNT_ID
LAMBDA_ARN=LAMBDA_ARN
# Build the release binary
cargo build --release --target=x86_64-unknown-linux-gnu
# Copy the release binary into the `bin` folder
mkdir -p ./bin
cp ./target/x86_64-unknown-linux-gnu/release/aws_secretsmanager_agent ./bin/secrets-manager-agent
# Copy the `secrets-manager-agent-extension.sh` example script into the `extensions` folder.
mkdir -p ./extensions
cp aws_secretsmanager_agent/examples/example-lambda-extension/secrets-manager-agent-extension.sh ./extensions
# Zip the extension shell script and the binary
zip secrets-manager-agent-extension.zip bin/* extensions/*
# Publish the layer version
LAYER_VERSION_ARN=$(aws lambda publish-layer-version \
--layer-name secrets-manager-agent-extension \
--zip-file "fileb://secrets-manager-agent-extension.zip" | jq -r '.LayerVersionArn')
```
1.
**Configure el token SSRF**
La configuración predeterminada del agente establecerá automáticamente el token SSRF en el valor establecido en las variables preestablecidas `AWS_SESSION_TOKEN` o de `AWS_CONTAINER_AUTHORIZATION_TOKEN` entorno (esta última variable para las funciones de Lambda si está habilitada). SnapStart Como alternativa, puede definir la variable de entorno `AWS_TOKEN` con un valor arbitrario para la función de Lambda, ya que esta variable tiene prioridad sobre las otras dos. Si decide utilizar la variable de entorno `AWS_TOKEN`, debe establecer esa variable de entorno con una llamada `lambda:UpdateFunctionConfiguration`.
1.
**Adjunte la capa a la función.**
Adjunte la versión de la capa a la función de Lambda:
```
# Attach the layer version to the Lambda function
aws lambda update-function-configuration \
--function-name $LAMBDA_ARN \
--layers "$LAYER_VERSION_ARN"
```
1.
**Actualizar el código de la función**
Actualice la función de Lambda para realizar consultas a `http://localhost:2773/secretsmanager/get?secretId=MyTest` con el valor del encabezado `X-Aws-codes-Secrets-Token` establecido en el valor del token SSRF procedente de una de las variables de entorno mencionadas anteriormente para recuperar el secreto. Asegúrese de implementar la lógica de reintento en el código de la aplicación para adaptarse a los retrasos en la inicialización y el registro de la extensión de Lambda.
1.
**Prueba de la función**
Invoque la función de Lambda para comprobar que el secreto se está recuperando correctamente.
------
## Recuperación de secretos con el Agente de Secrets Manager
Para recuperar un secreto, debe llamar al punto de conexión local del Agente de Secrets Manager con el nombre del secreto o ARN como parámetro de consulta. De forma predeterminada, el Agente de Secrets Manager recupera la versión `AWSCURRENT` del secreto. Para recuperar una versión diferente, utilice el parámetro versionStage o versionId.
**importante**
Para ayudar a proteger al Agente de Secrets Manager, debe incluir un encabezado de token SSRF como parte de cada solicitud: `X-Aws-Parameters-Secrets-Token`. El Agente de Secrets Manager rechaza las solicitudes que no tengan este encabezado o que tengan un token SSRF no válido. Puede personalizar el nombre del encabezado de SSRF en [Configuración del Agente de Secrets Manager](#secrets-manager-agent-config).
### Permisos necesarios
El agente Secrets Manager usa el AWS SDK de Rust, que usa la [cadena de proveedores de AWS credenciales](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html). La identidad de estas credenciales de IAM determina los permisos que tiene el Agente de Secrets Manager para recuperar los secretos.
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información sobre los permisos, consulte [Referencia de permisos para AWS Secrets Manager](auth-and-access.md#reference_iam-permissions).
**importante**
Tras introducir el valor secreto en el Agente de Secrets Manager, cualquier usuario con acceso al entorno informático y al token SSRF podrá acceder al secreto desde la memoria caché del Agente de Secrets Manager. Para obtener más información, consulte [Consideraciones de seguridad](#secrets-manager-agent-security).
### Solicitudes de ejemplo
------
#### [ curl ]
**Example Ejemplo: obtener un secreto con curl**
El siguiente ejemplo de curl muestra cómo obtener un secreto del Agente de Secrets Manager. El ejemplo se basa en la presencia de la SSRF en un archivo, que es donde se almacena mediante el script de instalación.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID' \\
echo
```
------
#### [ Python ]
**Example Ejemplo: obtener un secreto con Python**
El siguiente ejemplo de Python muestra cómo obtener un valor secreto del Agente de Secrets Manager. El ejemplo se basa en la presencia de la SSRF en un archivo, que es donde se almacena mediante el script de instalación.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Comprensión del parámetro `refreshNow`
El Agente de Secrets Manager utiliza una caché en memoria para almacenar valores de secretos, que actualiza periódicamente. Por defecto, esta actualización se produce cuando se solicita un secreto una vez transcurrido el tiempo de vida (TTL), normalmente cada 300 segundos. Sin embargo, este enfoque a veces puede dar como resultado valores de secretos obsoletos, especialmente si un secreto rota antes de que caduque la entrada del caché.
Para abordar esta limitación, el Agente de Secrets Manager admite un parámetro llamado `refreshNow` en la URL. Puedes usar este parámetro para forzar una actualización inmediata del valor de un secreto, omitiendo la caché y asegurándote de disponer de la mayor up-to-date cantidad de información.
**Comportamiento predeterminado (sin `refreshNow`)**
+ Utiliza valores en caché hasta que caduque el TTL
+ Actualiza los secretos solo después del TTL (por defecto, 300 segundos)
+ Puede devolver valores obsoletos si los secretos rotan antes de que caduque la caché
**Comportamientos de `refreshNow=true`**
+ Omite la memoria caché por completo
+ Recupera el último valor secreto directamente de Secrets Manager
+ Actualiza la caché con el valor nuevo y restablece el TTL
+ Garantiza que siempre se obtendrá el valor secreto más actualizado
### Actualización forzada de un valor secreto
**importante**
El valor predeterminado de `refreshNow` es `false`. Cuando se establece en `true`, anula el TTL especificado en el archivo de configuración del Agente de Secrets Manager y realiza una llamada de API a Secrets Manager.
------
#### [ curl ]
**Example Ejemplo: forzar la actualización de un secreto mediante curl**
El siguiente ejemplo de curl muestra cómo forzar el Agente de Secrets Manager para que actualice el secreto. El ejemplo se basa en la presencia de la SSRF en un archivo, que es donde se almacena mediante el script de instalación.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true' \\
echo
```
------
#### [ Python ]
**Example Ejemplo: forzar la actualización de un secreto mediante Python**
El siguiente ejemplo de Python muestra cómo obtener un valor secreto del Agente de Secrets Manager. El ejemplo se basa en la presencia de la SSRF en un archivo, que es donde se almacena mediante el script de instalación.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Configuración del Agente de Secrets Manager
Para cambiar la configuración del Agente de Secrets Manager, cree un archivo de configuración [TOML](https://toml.io/en/) y, a continuación, realice una llamada `./aws_secretsmanager_agent --config config.toml`.Opciones de configuración
**`log_level`**
El nivel de detalle indicado en los registros del Agente de Secrets Manager: DEBUG, INFO, WARN, ERROR o NONE. El valor predeterminado es INFO.
**`log_to_file`**
Si desea registrar en un archivo o en stdout/stderr: `true` o `false`. El valor predeterminado es `true`.
**`http_port`**
El puerto del servidor HTTP local, en el rango de 1024 a 65 535. El valor predeterminado es 2773.
**`region`**
La AWS región que se utilizará para las solicitudes. Si no se especifica ninguna región, el Agente de Secrets Manager determina la región a partir del SDK. Para obtener más información, consulte [Especifique las credenciales y regiones predeterminadas](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) en la *Guía para desarrolladores del SDK de AWS para Rust*.
**`ttl_seconds`**
El TTL en segundos de los elementos almacenados en caché, en el rango de 0 a 3600. El valor predeterminado es 300, donde 0 indica que no hay almacenamiento en caché.
**`cache_size`**
El número máximo de secretos que se pueden almacenar en caché está en el rango de 1 a 1000. El valor predeterminado es 1000.
**`ssrf_headers`**
Una lista de nombres de encabezados que el Agente de Secrets Manager comprueba en busca del token SSRF. El valor predeterminado es «X-Aws-Parameters-Secrets-Token,». X-Vault-Token
**`ssrf_env_variables`**
Una lista de nombres de variables de entorno que el Agente de Secrets Manager comprueba en orden secuencial en busca del token SSRF. La variable de entorno puede contener el token o una referencia al archivo del token, como en: `AWS_TOKEN=file:///var/run/awssmatoken`. El valor predeterminado es ", \$1TOKEN, \$1AUTHORIZATION\$1TOKEN». AWS\$1TOKEN AWS\$1SESSION AWS\$1CONTAINER
**`path_prefix`**
El prefijo URI que se utiliza para determinar si la solicitud es una solicitud basada en una ruta. El valor predeterminado es “/v1/”.
**`max_conn`**
El número máximo de conexiones desde clientes HTTP que permite el Agente de Secrets Manager, entre 1 y 1000. El valor predeterminado es 800.
## Características opcionales
El Agente de Secrets Manager se puede crear con características opcionales pasando el marcador `--features` a `cargo build`. Las características disponibles son las siguientes:Características de compilación
**`prefer-post-quantum`**
Crea `X25519MLKEM768` como el algoritmo de intercambio de claves de mayor prioridad. De lo contrario, está disponible pero no tiene la prioridad más alta. `X25519MLKEM768`es un algoritmo híbrido de intercambio de post-quantum-secure claves.
**`fips`**
Restringe los conjuntos de cifrado utilizados por el agente únicamente a los cifrados aprobados por el FIPS.
## Registro
**Registro local**
El Agente de Secrets Manager registra los errores localmente en el archivo `logs/secrets_manager_agent.log` o en stdout/stderr según la variable de configuración `log_to_file`. Cuando la aplicación llama al Agente de Secrets Manager para obtener un secreto, esas llamadas aparecen en el registro local. No aparecen en los CloudTrail registros.
**Rotación de registros**
El Agente de Secrets Manager crea un nuevo archivo de registro cuando el archivo alcanza los 10 MB y almacena hasta cinco archivos de registro en total.
**AWS registro de servicios**
El registro no va a Secrets Manager, CloudTrail, o CloudWatch. Las solicitudes para obtener secretos del Agente de Secrets Manager no aparecen en esos registros. Cuando el agente de Secrets Manager llama a Secrets Manager para obtener un secreto, esa llamada se graba CloudTrail con una cadena de agente de usuario que contiene`aws-secrets-manager-agent`.
Puede configurar las opciones del registro en [Configuración del Agente de Secrets Manager](#secrets-manager-agent-config).
## Consideraciones de seguridad
**Dominio de confianza**
En el caso de una arquitectura de agente, el dominio de confianza es el lugar donde se puede acceder al punto de conexión del agente y al token SSRF, que suele ser todo el host. El dominio de confianza del Agente de Secrets Manager debe coincidir con el dominio en el que están disponibles las credenciales de Secrets Manager para mantener la misma postura de seguridad. Por ejemplo, en Amazon EC2, el dominio de confianza del Agente de Secrets Manager sería el mismo que el dominio de las credenciales cuando se utilizan roles para Amazon EC2.
**importante**
Las aplicaciones preocupadas por la seguridad que aún no utilizan una solución de agente con las credenciales de Secrets Manager bloqueadas en la aplicación deberían considerar la posibilidad de utilizar soluciones de almacenamiento en caché AWS SDKs o específicas del idioma. Para obtener más información, consulte [Obtener secretos](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html).
# Obtenga un valor secreto de Secrets Manager con el AWS SDK de C\$1\$1
En el caso de las aplicaciones de C\$1\$1, llame al SDK directamente con [GetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/GetSecretValue)o [BatchGetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/BatchGetSecretValue).
El siguiente ejemplo de código muestra cómo obtener un valor secreto de Secrets Manager.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
//! Retrieve an AWS Secrets Manager encrypted secret.
/*!
\param secretID: The ID for the secret.
\return bool: Function succeeded.
*/
bool AwsDoc::SecretsManager::getSecretValue(const Aws::String &secretID,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SecretsManager::SecretsManagerClient secretsManagerClient(clientConfiguration);
Aws::SecretsManager::Model::GetSecretValueRequest request;
request.SetSecretId(secretID);
Aws::SecretsManager::Model::GetSecretValueOutcome getSecretValueOutcome = secretsManagerClient.GetSecretValue(
request);
if (getSecretValueOutcome.IsSuccess()) {
std::cout << "Secret is: "
<< getSecretValueOutcome.GetResult().GetSecretString() << std::endl;
}
else {
std::cerr << "Failed with Error: " << getSecretValueOutcome.GetError()
<< std::endl;
}
return getSecretValueOutcome.IsSuccess();
}
```
# Obtenga un valor secreto de Secrets Manager con el JavaScript AWS SDK
Para JavaScript las aplicaciones, llame al SDK directamente con [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property)o [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property).
El siguiente ejemplo de código muestra cómo obtener un valor secreto de Secrets Manager.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
import {
GetSecretValueCommand,
SecretsManagerClient,
} from "@aws-sdk/client-secrets-manager";
export const getSecretValue = async (secretName = "SECRET_NAME") => {
const client = new SecretsManagerClient();
const response = await client.send(
new GetSecretValueCommand({
SecretId: secretName,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '584eb612-f8b0-48c9-855e-6d246461b604',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// ARN: 'arn:aws:secretsmanager:us-east-1:xxxxxxxxxxxx:secret:binary-secret-3873048-xxxxxx',
// CreatedDate: 2023-08-08T19:29:51.294Z,
// Name: 'binary-secret-3873048',
// SecretBinary: Uint8Array(11) [
// 98, 105, 110, 97, 114,
// 121, 32, 100, 97, 116,
// 97
// ],
// VersionId: '712083f4-0d26-415e-8044-16735142cd6a',
// VersionStages: [ 'AWSCURRENT' ]
// }
if (response.SecretString) {
return response.SecretString;
}
if (response.SecretBinary) {
return response.SecretBinary;
}
};
```
# Obtén un valor secreto de Secrets Manager con el SDK de Kotlin AWS
Para las aplicaciones de Kotlin, llama al SDK directamente con [GetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)o. [BatchGetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)
El siguiente ejemplo de código muestra cómo obtener un valor secreto de Secrets Manager.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
suspend fun getValue(secretName: String?) {
val valueRequest =
GetSecretValueRequest {
secretId = secretName
}
SecretsManagerClient.fromEnvironment { region = "us-east-1" }.use { secretsClient ->
val response = secretsClient.getSecretValue(valueRequest)
val secret = response.secretString
println("The secret value is $secret")
}
}
```
# Obtenga un valor secreto de Secrets Manager con el AWS SDK de PHP
Para aplicaciones de PHP, llame al SDK directamente con [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue) o [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue).
El siguiente ejemplo de código muestra cómo obtener un valor secreto de Secrets Manager.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
>/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
// Create a Secrets Manager Client
$client = new SecretsManagerClient([
'profile' => 'default',
'version' => '2017-10-17',
'region' => '<<{{MyRegionName}}>>',
]);
$secret_name = '<<{{MySecretName}}>>';
try {
$result = $client->getSecretValue([
'SecretId' => $secret_name,
]);
} catch (AwsException $e) {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
throw $e;
}
// Decrypts secret using the associated KMS key.
$secret = $result['SecretString'];
// Your code goes here
```
# Obtenga un valor secreto de Secrets Manager con el AWS SDK de Ruby
Para aplicaciones de Ruby, llame al SDK directamente con [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method) o [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method).
El siguiente ejemplo de código muestra cómo obtener un valor secreto de Secrets Manager.
**Permisos necesarios: **`secretsmanager:GetSecretValue`
```
# Use this code snippet in your app.
# If you need more information about configurations or implementing the sample code, visit the AWS docs:
# https://aws.amazon.com/developer/language/ruby/
require 'aws-sdk-secretsmanager'
def get_secret
client = Aws::SecretsManager::Client.new(region: '<<{{MyRegionName}}>>')
begin
get_secret_value_response = client.get_secret_value(secret_id: '<<{{MySecretName}}>>')
rescue StandardError => e
# For a list of exceptions thrown, see
# https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
raise e
end
secret = get_secret_value_response.secret_string
# Your code goes here.
end
```
# Obtenga un valor secreto mediante el AWS CLI
**Permisos necesarios: **`secretsmanager:GetSecretValue`
**Example Recuperar el valor de secreto cifrado de un secreto**
El siguiente ejemplo de [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html) obtiene el valor de secreto actual.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
```
**Example Recuperar el valor de secreto anterior**
El siguiente ejemplo de [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html) obtiene el valor de secreto anterior.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
--version-stage AWSPREVIOUS
```
## Obtenga un grupo de secretos en un lote utilizando el AWS CLI
**Permisos necesarios: **
+ `secretsmanager:BatchGetSecretValue`
+ Permiso `secretsmanager:GetSecretValue` para cada uno de los secretos que desea recuperar.
+ Si utiliza filtros, también debe tenerlos `secretsmanager:ListSecrets`.
Si desea ver un ejemplo de política de permisos, consulte [Ejemplo: permiso para recuperar un grupo de valores secretos en un lote](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**importante**
Si tiene una política de VPCE que deniega el permiso para recuperar un secreto individual del grupo en recuperación, `BatchGetSecretValue` no devolverá ningún valor secreto y mostrará un error.
**Example Recupere el valor secreto de un grupo de secretos enumerados por nombre**
El siguiente ejemplo [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html) obtiene el valor del secreto para tres secretos.
```
aws secretsmanager batch-get-secret-value \
--secret-id-list MySecret1 MySecret2 MySecret3
```
**Example Recupere el valor secreto de un grupo de secretos seleccionado por el filtro**
En el siguiente [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html) ejemplo, se obtiene el valor secreto de los secretos que tienen una etiqueta denominada «Test».
```
aws secretsmanager batch-get-secret-value \
--filters Key="tag-key",Values="Test"
```
# Obtenga un valor secreto con la AWS consola
**Recuperar un secreto (consola)**
1. Abra la consola de Secrets Manager en [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. En la lista de secretos, elija el que desea recuperar.
1. En la sección **Valor secreto**, seleccione **Recuperar valor secreto**.
Secrets Manager muestra la versión actual (`AWSCURRENT`) del secreto. Para ver [otras versiones](whats-in-a-secret.md#term_version) del secreto, como versiones `AWSPREVIOUS` o versiones con etiquetas personalizadas, utilice [Obtenga un valor secreto mediante el AWS CLI](retrieving-secrets_cli.md).
# Usa AWS Secrets Manager secretos en AWS Batch
AWS Batch le ayuda a ejecutar cargas de trabajo de computación por lotes en el Nube de AWS. Con AWS Batch, puede introducir datos confidenciales en sus trabajos almacenándolos en AWS Secrets Manager secreto y luego haciendo referencia a ellos en su definición de trabajo. Para obtener más información, consulte [Especificación de información confidencial mediante Secrets Manager](https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data-secrets.html).
# Obtén un AWS Secrets Manager secreto en un CloudFormation recurso
Con CloudFormation, puedes recuperar un secreto para usarlo en otro CloudFormation recurso. Un escenario común consiste en crear primero un secreto con una contraseña generada por Secrets Manager y, a continuación, recuperar el nombre de usuario y la contraseña del secreto y utilizarlos como credenciales para una base de datos nueva. Para obtener información sobre cómo crear secretos con CloudFormation, consulte[Crea AWS Secrets Manager secretos en AWS CloudFormation](cloudformation.md).
Para recuperar un secreto de una CloudFormation plantilla, utilice una *referencia dinámica*. Al crear la pila, la referencia dinámica introduce el valor secreto en el CloudFormation recurso, por lo que no es necesario codificar la información secreta. En su lugar, se hace referencia al secreto por su nombre o ARN. Se puede utilizar una referencia dinámica para un secreto en cualquier propiedad de un recurso. No se puede utilizar una referencia dinámica para un secreto en metadatos de un recurso tales como [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html), ya que eso provocaría que el valor de secreto fuera visible en la consola.
Una referencia dinámica de un secreto tiene el siguiente patrón:
```
{{resolve:secretsmanager:secret-id:SecretString:json-key:version-stage:version-id}}
```
**id-secreto**
El nombre o el ARN del secreto. Para acceder a un secreto de tu AWS cuenta, puedes usar el nombre secreto. Para acceder a un secreto de otra AWS cuenta, usa el ARN del secreto.
**clave-json** (Opcional)
El nombre de la clave del par clave-valor cuyo valor desea recuperar. Si no especificas un`json-key`, CloudFormation recupera todo el texto secreto. Este segmento no puede incluir el signo de dos puntos (`:`).
**fase-versión** (Opcional)
La [version](whats-in-a-secret.md#term_version) del secreto que se debe utilizar. Secrets Manager utiliza etiquetas provisionales para realizar un seguimiento de las diferentes versiones durante el proceso de rotación. Si usa `version-stage`, no especifique `version-id`. Si no especifica `version-stage` ni `version-id`, la versión predeterminada es la `AWSCURRENT`. Este segmento no puede incluir el signo de dos puntos (`:`).
**id-versión** (Opcional)
El identificador único de la versión del secreto a utilizar. Si especifica `version-id`, no especifique `version-stage`. Si no especifica `version-stage` ni `version-id`, la versión predeterminada es la `AWSCURRENT`. Este segmento no puede incluir el signo de dos puntos (`:`).
Para obtener más información, consulte [Uso de referencias dinámicas para especificar secretos en Secrets Manager](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**nota**
No cree una referencia dinámica con una barra invertida `(\)` como valor final. CloudFormation no puede resolver esas referencias, lo que provoca una falla en el recurso.
# Usa AWS Secrets Manager secretos en los GitHub trabajos
Para usar un secreto en un GitHub trabajo, puedes usar una GitHub acción para recuperar los secretos AWS Secrets Manager y añadirlos como [variables de entorno](https://docs.github.com/en/actions/learn-github-actions/environment-variables) enmascaradas en tu GitHub flujo de trabajo. Para obtener más información sobre GitHub las acciones, consulte [Descripción de GitHub las acciones](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions) en los *GitHub documentos*.
Cuando añades un secreto a tu GitHub entorno, estará disponible para todos los demás pasos de tu GitHub trabajo. Siga las instrucciones de [Security Hardening for GitHub Actions para](https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions) evitar que se haga un uso indebido de los secretos de su entorno.
Puede establecer la cadena completa del valor del secreto como el valor de la variable de entorno o, si la cadena es JSON, puede analizar el elemento JSON para establecer variables de entorno individuales para cada par clave-valor de JSON. Si el valor del secreto es binario, la acción lo convierte en una cadena.
Para ver las variables de entorno creadas a partir de sus secretos, active el registro de depuración. *Para obtener más información, consulte [Habilitar el registro de depuración](https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging) en los documentos. GitHub *
Para usar las variables de entorno creadas a partir de tus secretos, consulta [Variables de entorno](https://docs.github.com/en/actions/learn-github-actions/environment-variables) en los *GitHub documentos*.
## Requisitos previos
Para usar esta acción, primero debes configurar AWS las credenciales y configurarlas Región de AWS en tu GitHub entorno siguiendo este `configure-aws-credentials` paso. Siga las instrucciones de la [acción Configurar AWS credenciales para que GitHub las acciones](https://github.com/aws-actions/configure-aws-credentials) **asuman el rol directamente mediante el proveedor GitHub OIDC**. Esto permite utilizar credenciales de corta duración y evitar almacenar claves de acceso adicionales fuera de Secrets Manager.
El rol de IAM que asume la acción debe tener los siguientes permisos:
+ `GetSecretValue` sobre los secretos que quiere recuperar.
+ `ListSecrets` sobre todos los secretos.
+ (Opcional) KMS key si `Decrypt` los secretos están cifrados con un. clave administrada por el cliente
Para obtener más información, consulte [Autenticación y control de acceso para AWS Secrets Manager](auth-and-access.md).
## De uso
Para utilizar la acción, agregue un paso al flujo de trabajo que emplea la siguiente sintaxis.
```
- name: Step name
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
secretId1
ENV_VAR_NAME, secretId2
name-transformation: (Optional) uppercase|lowercase|none
parse-json-secrets: (Optional) true|false
```Parameters
`secret-ids`
ARN, nombres y prefijos de nombres de los secretos.
Para establecer el nombre de la variable de entorno, escríbalo antes del identificador del secreto, seguido de una coma. Por ejemplo, `ENV_VAR_1, secretId` crea una variable de entorno denominada **ENV\$1VAR\$11** a partir del `secretId` del secreto. El nombre de las variables de entorno pueden componerse de letras mayúsculas, números y guiones bajos.
Para usar un prefijo, ingrese al menos tres caracteres seguidos de un asterisco. Por ejemplo, `dev*` hace coincidir todos los secretos con un nombre que comience por **dev**. El número máximo de secretos coincidentes que pueden recuperarse es de 100. Si establece el nombre de la variable y el prefijo coincide con varios secretos, la acción devuelve un error.
`name-transformation`
De forma predeterminada, el paso crea el nombre de cada variable de entorno a partir del nombre del secreto, transformado para incluir solo letras mayúsculas, números y guiones bajos, de modo que no comience con un número. En el caso de las letras del nombre, puede configurar el paso para usar letras minúsculas con `lowercase` o no cambiar el tipo de letra con `none`. El valor predeterminado es `uppercase`.
`parse-json-secrets`
(Opcional) De forma predeterminada, la acción establece el valor de la variable de entorno en toda la cadena JSON del valor del secreto. Establezca `parse-json-secrets` en `true` para crear variables de entorno para cada par clave-valor en el archivo JSON.
Tenga en cuenta que, si el archivo JSON utiliza claves que distinguen entre mayúsculas y minúsculas, como “nombre” y “Nombre”, la acción tendrá conflictos de nombres duplicados. En este caso, establezca `parse-json-secrets` en `false` y analice el valor del secreto de JSON por separado.
## Nombre de variable de entorno
Las variables de entorno creadas por la acción reciben el mismo nombre que los secretos de los que provienen. Las variables de entorno tienen requisitos de nomenclatura más estrictos que los secretos, por lo que la acción transforma los nombres de los secretos para cumplir esos requisitos. Por ejemplo, la acción transforma las letras minúsculas en mayúsculas. Si analiza el JSON del secreto, el nombre de la variable de entorno incluye tanto el nombre del secreto como el nombre de la clave JSON, por ejemplo, `MYSECRET_KEYNAME`. Puede configurar la acción para que no transforme las letras minúsculas.
Si dos variables de entorno terminan con el mismo nombre, la acción fallará. En este caso, debe especificar los nombres que quiere usar para las variables de entorno como *alias*.
Ejemplos de casos en los que los nombres pueden entrar en conflicto:
+ Tanto un secreto llamado «MySecret» como un secreto llamado «mysecret» se convertirían en variables de entorno denominadas «MYSECRET».
+ Tanto un secreto denominado “Secret\$1keyname” como un secreto analizado por JSON denominado “Secret” con una clave denominada “keyname” se convertirían en variables de entorno denominadas “SECRET\$1KEYNAME”.
Puede establecer el nombre de la variable de entorno especificando un *alias*, como se muestra en el siguiente ejemplo, que crea una variable denominada `ENV_VAR_NAME`.
```
secret-ids: |
ENV_VAR_NAME, secretId2
```
**Alias en blanco**
+ Si establece `parse-json-secrets: true` e introduce un alias en blanco, seguido de una coma y, a continuación, el ID del secreto, la acción asignará a la variable de entorno el mismo nombre que a las claves JSON analizadas. Los nombres de las variables no incluyen el nombre del secreto.
Si el secreto no contiene un JSON válido, la acción crea una variable de entorno y le asigna el mismo nombre que el nombre del secreto.
+ Si establece `parse-json-secrets: false` e introduce un alias en blanco, seguido de una coma y el ID del secreto, la acción asigna un nombre a las variables de entorno como si no hubiera especificado un alias.
El siguiente ejemplo muestra un alias en blanco.
```
,secret2
```
## Ejemplos
**Example 1. Obtención de secretos por nombre y por ARN**
En el ejemplo siguiente, se crean variables de entorno para los secretos identificados por nombre y por ARN.
```
- name: Get secrets by name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
exampleSecretName
arn:aws:secretsmanager:us-east-2:123456789012:secret:test1-a1b2c3
0/test/secret
/prod/example/secret
SECRET_ALIAS_1,test/secret
SECRET_ALIAS_2,arn:aws:secretsmanager:us-east-2:123456789012:secret:test2-a1b2c3
,secret2
```
Variables de entorno creadas:
```
EXAMPLESECRETNAME: secretValue1
TEST1: secretValue2
_0_TEST_SECRET: secretValue3
_PROD_EXAMPLE_SECRET: secretValue4
SECRET_ALIAS_1: secretValue5
SECRET_ALIAS_2: secretValue6
SECRET2: secretValue7
```
**Example 2. Obtención de todos los secretos que comienzan por un prefijo**
En el siguiente ejemplo, se crean variables de entorno para todos los secretos con nombres que comienzan por. *beta*
```
- name: Get Secret Names by Prefix
uses: 2
with:
secret-ids: |
beta* # Retrieves all secrets that start with 'beta'
```
Variables de entorno creadas:
```
BETASECRETNAME: secretValue1
BETATEST: secretValue2
BETA_NEWSECRET: secretValue3
```
**Example 3. Análisis del archivo JSON en secreto**
En el siguiente ejemplo, se crean variables de entorno mediante el análisis del archivo JSON del secreto.
```
- name: Get Secrets by Name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
test/secret
,secret2
parse-json-secrets: true
```
El secreto `test/secret` tiene el siguiente valor del secreto.
```
{
"api_user": "user",
"api_key": "key",
"config": {
"active": "true"
}
}
```
El secreto `secret2` tiene el siguiente valor del secreto.
```
{
"myusername": "alejandro_rosalez",
"mypassword": "EXAMPLE_PASSWORD"
}
```
Variables de entorno creadas:
```
TEST_SECRET_API_USER: "user"
TEST_SECRET_API_KEY: "key"
TEST_SECRET_CONFIG_ACTIVE: "true"
MYUSERNAME: "alejandro_rosalez"
MYPASSWORD: "EXAMPLE_PASSWORD"
```
**Example 4. Uso de letras minúsculas para los nombres de las variables de entorno**
En el siguiente ejemplo, se crea una variable de entorno con un nombre en minúscula.
```
- name: Get secrets
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: exampleSecretName
name-transformation: lowercase
```
Variable de entorno creada:
```
examplesecretname: secretValue
```
# Uso AWS Secrets Manager en GitLab
AWS Secrets Manager se integra con GitLab. Puede aprovechar los secretos de Secrets Manager para proteger sus GitLab credenciales y evitar que estén codificadas GitLab. En su lugar, [GitLab Runner](https://docs.gitlab.com/runner/) recupera estos secretos de Secrets Manager cuando la aplicación ejecuta un trabajo en las canalizaciones de GitLab CI/CD.
Para usar esta integración, creará un [proveedor de identidad OpenID Connect (OIDC) en IAM y un rol de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html) AWS Identity and Access Management . Esto le permite a GitLab Runner acceder a tu secreto de Secrets Manager. [Para obtener más información sobre el GitLab CI/CD y el OIDC, consulte la documentación. GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
## Consideraciones
Si utilizas una GitLab instancia no pública, no puedes usar esta integración de Secrets Manager. En su lugar, consulte [GitLab la documentación de las instancias no públicas](https://docs.gitlab.com/ci/cloud_services/aws/#configure-a-non-public-gitlab-instance).
## Requisitos previos
Para integrar Secrets Manager con GitLab, complete los siguientes requisitos previos:
1.
**Crea un secreto AWS Secrets Manager**
Necesitarás un secreto de Secrets Manager que se recuperará en tu GitLab trabajo y que eliminará la necesidad de codificar estas credenciales de forma rígida. Necesitarás el ID secreto de Secrets Manager cuando [configures tu GitLab canalización](#configure-gitlab-pipeline). Para obtener más información, consulte [Crea un AWS Secrets Manager secreto](create_secret.md).
1.
**Configura GitLab tu proveedor de OIDC en la consola de IAM.**
En este paso, seleccionará GitLab su proveedor de OIDC en la consola de IAM. [Para obtener más información, consulte [Crear un proveedor de identidad y la documentación de OpenID Connect (OIDC)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_providers_create_oidc.html). GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
Al crear el proveedor de OIDC en la consola de IAM, debe utilizar las siguientes configuraciones:
1. Configúrelo en `provider URL` su instancia. GitLab Por ejemplo, **gitlab.example.com**.
1. Establezca `audience` o `aud` en **sts.amazonaws.com**.
1.
**Creación de una política y un rol de IAM**
Deberá crear un rol de IAM y una política. GitLab with [AWS Security Token Service (STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) asume esta función. Para obtener más información, consulte [Crear un rol mediante políticas de confianza personalizadas](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-custom.html).
1. En la consola de IAM, utilice la siguiente configuración al crear el rol de IAM:
+ Establece `Trusted entity type` en **Web identity**.
+ Establece `Group` en **your GitLab group**.
+ `Identity provider`Configúrelo en la misma URL del proveedor (la [GitLab instancia](#step2-oidc-provider)) que utilizó en el paso 2.
+ Establezca `Audience` en la misma [audiencia](#step2-oidc-audience) que utilizó en el paso 2.
1. El siguiente es un ejemplo de una política de confianza que GitLab permite asumir funciones. Tu política de confianza debe incluir tu Cuenta de AWS GitLab URL y la [ruta del proyecto](https://docs.gitlab.com/user/project/).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRoleWithWebIdentity",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/gitlab.example.com"
},
"Condition": {
"StringEquals": {
"gitlab.example.com:aud": [
"sts.amazon.com"
]
},
"StringLike": {
"gitlab.example.com:sub": [
"project_path:mygroup/project-*:ref_type:branch-*:ref:main*"
]
}
}
}
]
}
```
1. También tendrás que crear una política de IAM para permitir el GitLab acceso a AWS Secrets Manager. Puede agregar esta política a la política de confianza. Para obtener más información, consulte [Creación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:your-secret"
}
]
}
```
## Integrarse con AWS Secrets Manager GitLab
Tras cumplir los requisitos previos, puede configurar GitLab el uso de Secrets Manager para proteger sus credenciales.
### Configurar la GitLab canalización para usar Secrets Manager
Deberá actualizar el [archivo de configuración de GitLab CI/CD](https://docs.gitlab.com/ci/yaml/yaml_optimization/) con la siguiente información:
+ La audiencia del token establecido en STS.
+ El ID del secreto de Secrets Manager.
+ La función de IAM que quieres que asuma GitLab Runner al ejecutar tareas en proceso. GitLab
+ El Región de AWS lugar donde se guarda el secreto.
GitLab obtiene el secreto de Secrets Manager y almacena el valor en un archivo temporal. La ruta a este archivo se almacena en una CI/CD variable, similar a las variables [CI/CD de tipo archivo](https://docs.gitlab.com/ci/variables/#use-file-type-cicd-variables).
El siguiente es un fragmento del archivo YAML para un archivo de configuración de CI/CD: GitLab
```
variables:
AWS_REGION: us-east-1
AWS_ROLE_ARN: 'arn:aws:iam::111122223333:role/gitlab-role'
job:
id_tokens:
AWS_ID_TOKEN:
aud: 'sts.amazonaws.com'
secrets:
DATABASE_PASSWORD:
aws_secrets_manager:
secret_id: "arn:aws:secretsmanager:us-east-1:111122223333:secret:secret-name"
```
Para obtener más información, consulte la [documentación de integración de GitLab Secrets Manager](https://docs.gitlab.com/ci/secrets/aws_secrets_manager/).
Si lo desea, puede probar su configuración de OIDC en. GitLab Consulte [GitLab la documentación para probar la configuración del OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#test-the-oidc-configuration) para obtener más información.
## Resolución de problemas
Lo siguiente puede ayudarlo a solucionar problemas comunes que pueden surgir al integrar Secrets Manager con GitLab.
### GitLab Problemas de canalización
Si tienes problemas con la GitLab canalización, asegúrate de lo siguiente:
+ El archivo YAML tiene el formato correcto. Para obtener más información, consulte [Documentación de GitLab](https://docs.gitlab.com/ee/ci/yaml/).
+ Tu GitLab canalización asume la función correcta, tiene los permisos adecuados y acceso al AWS Secrets Manager secreto correcto.
### Recursos adicionales
Los siguientes recursos pueden ayudarte a solucionar problemas relacionados con GitLab y AWS Secrets Manager:
+ [GitLab Solución de problemas del OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#troubleshooting)
+ [Depuración GitLab de la canalización de CI/CD](https://docs.gitlab.com/ee/ci/troubleshooting.html)
+ [Resolución de problemas](ascp-eks-installation.md#troubleshooting)
# Usa AWS Secrets Manager secretos en AWS IoT Greengrass
AWS IoT Greengrass es un software que extiende las capacidades de la nube a los dispositivos locales. Esto permite que los dispositivos recopilen y analicen datos más cerca del origen de la información, reaccionen de forma autónoma a eventos locales y se comuniquen de forma segura entre sí en las redes locales.
AWS IoT Greengrass le permite autenticarse con servicios y aplicaciones desde AWS IoT Greengrass dispositivos sin necesidad de codificar contraseñas, identificadores u otros secretos. Puede utilizarla AWS Secrets Manager para almacenar y gestionar de forma segura sus datos secretos en la nube. AWS IoT Greengrass extiende Secrets Manager a los dispositivos AWS IoT Greengrass principales, de modo que sus conectores y funciones de Lambda puedan usar secretos locales para interactuar con servicios y aplicaciones.
Para integrar un secreto en un AWS IoT Greengrass grupo, debe crear un recurso de grupo que haga referencia al secreto de Secrets Manager. Este recurso de secretos hace referencia al secreto en la nube mediante el ARN asociado. Para obtener información sobre cómo crear, administrar y usar recursos secretos, consulte Cómo [trabajar con recursos secretos](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets-using.html) en la Guía para AWS IoT desarrolladores.
Para desplegar secretos en el AWS IoT Greengrass núcleo, consulta Cómo [implementar secretos en el AWS IoT Greengrass núcleo.](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets.html)
# Usa AWS Secrets Manager secretos en Parameter Store
AWS El almacén de parámetros de Systems Manager proporciona un almacenamiento jerárquico y seguro para la gestión de los datos de configuración y la gestión de secretos. Puede almacenar datos como contraseñas, cadenas de base de datos y códigos de licencia como valores de parámetros. No obstante, el Almacén de parámetros no proporciona servicios de rotación automática para los secretos almacenados. En su lugar, Parameter Store le permite almacenar el secreto en Secrets Manager y, a continuación, hacer referencia al secreto como parámetro de Parameter Store.
Cuando se configura Parameter Store con Secrets Manager, el `secret-id` de Parameter Store necesita que se incluya una barra diagonal (/) antes de la cadena de nombre.
Para obtener más información, consulte Hacer [referencia a AWS Secrets Manager los secretos de los parámetros del almacén de parámetros](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html) en la Guía del *AWS Systems Manager usuario*.