Cuando trabajamos con aplicaciones reactivas en Spring WebFlux, muchas veces necesitamos transformar datos entre distintas capas de la aplicación. En este post, veremos cómo usar ObjectMapper para mapear resultados de una base de datos a objetos de dominio en un entorno no bloqueante.

Contexto del código

Supongamos que tienes un servicio que obtiene configuraciones desde una base de datos reactiva, filtradas por un estado. Este es el método que implementamos:

  testImplementation 'org.reactivecommons.utils:object-mapper:0.1.0'
    implementation 'org.reactivecommons.utils:object-mapper:0.1.0'

Uso

private final ObjectMapper objectMapper;


@Override
public Flux<> getConfig(String state) {
    return repository.findByState(state)
            .map(res -> objectMapper.convertValue(res, ProcessConfig.class));
}

🔍 Desglosemos cada parte

1. private final ObjectMapper objectMapper;

ObjectMapper es una clase de la biblioteca Jackson, muy usada para convertir objetos Java en JSON y viceversa. Sin embargo, también es útil para mapear entre diferentes clases Java (por ejemplo, de entidades a DTOs o clases de dominio).

Se declara como private final para asegurar que:

• Privado: Solo la clase actual puede acceder al mapper.
• Final: No puede ser reasignado, lo cual es ideal para componentes inyectados.

💡 En una aplicación Spring Boot, normalmente se inyecta vía constructor para que esté gestionado por el contenedor de Spring.

2. repository.findByState(state)

Este método devuelve un Flux<Entidad>, es decir, un flujo reactivo de elementos que cumplen con el filtro state.

⚠️ Asumimos que res es una entidad que viene directamente del repositorio, probablemente una entidad JPA o una clase específica de persistencia.

3. .map(res -> objectMapper.convertValue(res, ProcessConfig.class))

Aquí ocurre la magia. Cada resultado del Flux es transformado (map) a una nueva instancia de ReentryProcessConfig.

Esto es útil si tu capa de persistencia devuelve una clase diferente a la que usas en la lógica de negocio. Por ejemplo:

• ProcessConfigEntity (persistencia) → ProcessConfig (dominio)

🧠 ¿Por qué no usar directamente el constructor o un mapper manual?

• Simplicidad: ObjectMapper puede copiar todos los campos que coincidan en nombre y tipo, sin escribir código repetitivo.
• Flexibilidad: Puedes aprovechar anotaciones como @JsonIgnore o @JsonProperty.
• Compatibilidad: Útil si ya usas Jackson en otros puntos del sistema.

🧼 Buenas prácticas

• ✅ Usa ObjectMapper solo cuando las clases sean similares y no haya lógica de transformación compleja.
• ✅ Considera usar MapStruct o ModelMapper si necesitas mayor control o rendimiento.
• ✅ Asegúrate de no introducir errores silenciosos: ObjectMapper no lanza excepciones si faltan campos, lo cual puede ocultar bugs.

🎯 Conclusión

El uso de ObjectMapper en servicios reactivas como Flux permite transformar fácilmente entidades a objetos de dominio sin bloquear el flujo de datos. Es una herramienta poderosa que, usada con cuidado, puede hacer tu código más limpio y mantenible.

Uno de los principales problemas al manejar grandes cantidades de datos es la capacidad limitada de la máquina encargada de procesarlos. Almacenar la información en memoria no garantiza un sistema resiliente, ya que, en caso de falla, se requeriría reiniciar el proceso desde cero. A continuación, se presenta un caso de uso para una estación de datos, cuyo almacenamiento posterior se realiza en un archivo en S3. Este enfoque permitirá paralelizar las consultas y transformaciones en diferentes nodos, de manera que, si alguno de ellos falla, solo se necesite reprocesar la parte faltante y no toda la información.

1. Initiate Multipart Upload: (master) , Cuando envía una solicitud para iniciar una carga multipart.
2. Carga de las partes: (Slaves) En cada solicitud de carga, debe incluir el ID de la carga multiparte que obtuvo en el paso 1.
3. Finalización (o detención) de una carga multiparte:(master), Después de cargar todas las partes del archivo, puede utilizar la operación de finalización. Una vez más, debe especificar el ID de carga en la solicitud. 

Ejemplo de uso extrayendo datos de una base de datos, el cual usa la funcionalidad anterior mente mencionada, pero el tema de paralelismo y entre los nodos depende mucho de tu arquitectura o diseño, :

   public Mono<Void> uploadFile(LocalDate processDate, String bucketName, String kmsKeyId) {
        String objectKey = "folder/file.txt";
        Mono<String> headerMono = Mono.fromCallable(this::getLineHeaderFile);
        return s3Operation.initiateMultipartUpload(bucketName, objectKey , kmsKeyId)
                .zipWith(headerMono)
                .flatMap(res -> uploadFilePart(Tuples.of(processDate, res.getT2()),
                        bucketName, objectKey, res.getT1())
                        .zipWith(Mono.just(res))
                )
                .flatMap(res1 -> {
                    var uploadId = res1.getT2().getT1();
                    return s3Operation.completeMultipartUpload(bucketName, objectKey, uploadId, res1.getT1());
                })
                .flatMap(res -> {
                    log.info(res);
                    return Mono.empty();
                });
    }

   
    private String getLineDetailFile(Data  data){
    //justify data a string
    return "test data";

    }
   
   public Flux<String> getDataToFile(LocalDate initRange, LocalDate endRange) {
        return infoReaderRepository
                .getAll(initRange, endRange) // get info
                .map(this::getLineDetailFile);
    }
 
 public Flux<Tuple2<Long, List<String>>> getRangeDate(LocalDate processDate) {
    return Flux.just("1", "2")
                .flatMap(res -> getDataToFile(res.getT1(), res.getT2()))
                .buffer(100000)
                .index()
                .parallel()
                .runOn(Schedulers.boundedElastic()).sequential();
    }
  
  
  
  public Mono<List<Tuple2<Integer, String>>> uploadFilePart(Tuple2<LocalDate, String> processDate,
                                                                            String bucketName, String objectKey,
                                                                            String uploadId) {

        return getRangeDate(processDate.getT1())
                .flatMap(res -> getByte(res.getT2(), res.getT1(), processDate.getT2())
                        .zipWith(Mono.just(res.getT1())
                        ))
                .flatMap(res -> {
                    log.info("length  " + res.getT1().length);
                    var partNumber = Math.toIntExact(res.getT2() + 1);
                    return s3Operation.multipartUpload(bucketName, objectKey, uploadId, res.getT1(), partNumber)
                            .map(tag -> Tuples.of(partNumber, tag));
                })
                .collectList();
    }
    

validamos las partes o la data pese mas de 5 mg , y concatenamos el header del archivo en este caso

 public Mono<byte[]> getByte(List<String> res, Long index, String header) {
        return Mono.just(res.stream()
                        .reduce("", (acc, line) -> acc + line).
                        getBytes(StandardCharsets.UTF_8))
                .map(str -> {
                    byte[] byteArray = str;
                    final int MIN_SIZE = 5 * 1024 * 1024;
                    if (index == 0) {
                        byte[] bytes1 = header.getBytes(StandardCharsets.UTF_8);
                        byte[] combinedBytes = new byte[bytes1.length + str.length];
                        System.arraycopy(bytes1, 0, combinedBytes, 0, bytes1.length);
                        System.arraycopy(str, 0, combinedBytes, bytes1.length, str.length);
                        byteArray = combinedBytes;
                    }
                    if ((byteArray.length < MIN_SIZE)) {
                        var paddedArray = new byte[MIN_SIZE];
                        System.arraycopy(byteArray, 0, paddedArray, 0, byteArray.length);
                        Arrays.fill(paddedArray, byteArray.length, MIN_SIZE, (byte) 0);
                        byteArray = paddedArray;
                    }
                    return byteArray;
                });
    }
    

En el adaptador de s3 vamos a tener la implementación de s3Operation

AdapterS3.java

private final S3BucketOperations s3Operations;


    @Override
    public Mono<List<String>> getItems(String bucketName) {
        return s3Operations.listBucketObjects(bucketName)
                .flatMap(s3Objects ->
                        Mono.just(
                                s3Objects.stream().map(S3Object::key)
                                        .collect(Collectors.toList())
                        )
                );

    }


    @Override
    public Mono<String> initiateMultipartUpload(String bucketName, String objectKey , String kmsKeyId) {
        CreateMultipartUploadRequest createRequest = CreateMultipartUploadRequest.builder()
                .bucket(bucketName)
                .key(objectKey)
                .serverSideEncryption(ServerSideEncryption.AWS_KMS)
                .ssekmsKeyId(kmsKeyId)
                .build();
        return s3Operations.initiateMultipartUpload(createRequest);
    }


    @Override
    public Mono<String> multipartUpload(String bucketName, String objectKey, String uploadId, byte[] part, int partNumber) {

        return s3Operations.uploadPart(bucketName, objectKey, uploadId, partNumber, part)
                .map(UploadPartResponse::eTag)
                .log(" Part uploaded: ")
                .onErrorResume(e -> {
                    log.info("Error multipartUpload part: " + e.getMessage());
                    return Mono.error(e);
                });

    }

    @Override
    public Mono<String> completeMultipartUpload(String bucketName, String objectKey, String uploadId, List<Tuple2<Integer, String>> eTags) {
        List<CompletedPart> completedParts = eTags.stream()
                .map(tuple ->
                        CompletedPart.builder()
                                .partNumber(tuple.getT1())
                                .eTag(tuple.getT2())
                                .build()
                )
                .sorted(Comparator.comparingInt(CompletedPart::partNumber))
                .collect(Collectors.toList());

        log.info("completedParts: " + completedParts);
        CompleteMultipartUploadRequest completeRequest = CompleteMultipartUploadRequest.builder()
                .bucket(bucketName)
                .key(objectKey)
                .uploadId(uploadId)
                .multipartUpload(CompletedMultipartUpload.builder().parts(completedParts).build())
                .build();
        return s3Operations.completeMultipartUpload(completeRequest)
                .then(Mono.just(uploadId))
                .onErrorResume(e -> {
                    log.info("Error completeMultipartUpload part: " + e.getMessage());
                    return Mono.error(e);
                });
    }

    

S3BucketOperations.java

    private final S3AsyncClient s3AsyncClient;


    public Mono<Void> completeMultipartUpload( CompleteMultipartUploadRequest completeRequest ) {

        return Mono.fromFuture(() -> s3AsyncClient.completeMultipartUpload(completeRequest))
                .then()
                .onErrorResume(e ->{
                    log.info("Error completeMultipartUpload part: "+e.getMessage());
                    return Mono.error(e);
                });
    }

    public Mono<UploadPartResponse> uploadPart(String bucketName, String objectKey, String uploadId,
                                                Integer partNumber, byte[] partData) {
        UploadPartRequest uploadPartRequest = UploadPartRequest.builder()
                .bucket(bucketName)
                .key(objectKey)
                .uploadId(uploadId)
                .partNumber(partNumber)
                .build();

        return Mono.fromFuture(() -> s3AsyncClient.uploadPart(uploadPartRequest , AsyncRequestBody.fromBytes(partData)))
                .onErrorResume(e ->{
                  log.info("Error uploading part: "+e.getMessage());
                    return Mono.error(e);
                });
    }
    public Mono<String> initiateMultipartUpload(CreateMultipartUploadRequest createRequest) {

        return Mono.fromFuture(() -> s3AsyncClient.createMultipartUpload(createRequest))
                .map(CreateMultipartUploadResponse::uploadId)
                .onErrorResume(e ->{
                    log.info("Error initiateMultipartUpload part: "+e.getMessage());
                    return Mono.error(e);
                });
    }


    public Mono<Boolean> uploadObject(String bucketName,String objectKey, byte[] fileContent) {

        return Mono.fromFuture(
                s3AsyncClient.putObject(configurePutObject(bucketName,objectKey),
                        AsyncRequestBody.fromBytes(fileContent)))
                .map(response -> response.sdkHttpResponse().isSuccessful());
    }

    public Mono<List<S3Object>> listBucketObjects(String bucketName){
        return Mono.fromFuture(s3AsyncClient.listObjects(ListObjectsRequest
                .builder()
                .bucket(bucketName)
                .build())).map(ListObjectsResponse::contents);
    }

    public Mono<InputStream> getObject(String bucketName,String objectKey) {
        Mono.fromFuture(s3AsyncClient.deleteObject(DeleteObjectRequest.builder()
                .bucket(bucketName)
                .key(objectKey).build()))
                .delayElement(Duration.ofMinutes(1))
                .subscribe();
        return Mono.fromFuture(s3AsyncClient.getObject(GetObjectRequest.builder()
                .key(objectKey)
                .bucket(bucketName)
                .build(), AsyncResponseTransformer.toBytes()))
                .map(BytesWrapper::asInputStream);
    }

    private PutObjectRequest configurePutObject(String bucketName, String objectKey) {
        return PutObjectRequest.builder()
                .bucket(bucketName)
                .key(objectKey)
                .build();
    }
    

happy code :).

Referencias:

Carga de archivos grandes por partes con Amazon SDK for Java - Amazon S3 Glacier

Ejemplos de código Java acerca de cómo cargar archivos grandes por partes en S3 Glacier con Amazon SDK para Java.

Amazon S3 Glacier

​​How to Upload Large Files Efficiently with AWS S3 Multipart Upload

Imagine running a media streaming platform where users upload large high-definition videos. Uploading such large files can be slow and may fail if the network is unreliable. Using traditional single-part uploads can be cumbersome and inefficient for…

freeCodeCamp.orgDestiny Erhabor

Una de las ventajas que tiene el cluster rds , la posibilidad de tener instancias en Multi-AZ, las cuales te permite tener alta disponibilidad de tu cluster de base de datos, cuando hay Failover en caso de fallos, RDS cambia automáticamente a la instancia diferente, pude suceder que el pool de conexión se quede en la instacia que no es de escritura

cannot execute UPDATE in a read-only transaction

En Spring Boot hay diferentes componentes que se utiliza para verificar la salud de una conexión con la base de datos,ConnectionFactory, Este indicador de salud forma parte de las capacidades de gestión de salud permitiendo monitorear el estado de las conexiones de manera efectiva, normal mente ConnectionFactoryHealthIndicator te habitaría que fallo la conexion, pero en algunos caso algunos pods o instancias de nuestra aplicacion no se conecta de forma correcta .

para poder identificar mejor como esta el pool y si esta usando el pool correcto vamos a customizar HealthCheck, que revise que este conectado de forma correcta.

1. implementamos la dependencia

org.springframework.boot:spring-boot-starter-actuator

1. Creamos la clase ConnectionPoolValidator, la cual se va encargar de consultar , que no la instancia no sea de lectura con el comando

SHOW transaction_read_only;

@Log
@Component
public class ConnectionPoolValidator {
    private final ConnectionPool connectionPool;

    public ConnectionPoolValidator( @Qualifier("postgresConnection") ConnectionPool connectionPool) {
        this.connectionPool = connectionPool;
    }

    public Flux<Boolean> validateConnection() {
        return connectionPool.create()
                .flatMapMany(connection -> connection
                        .createStatement("SHOW transaction_read_only;")
                        .execute())
                .flatMap(result -> result.map((row, rowMetadata) -> row.get(0, String.class)))
                .flatMap(value -> {
                    log.info("Connection not reader is: " + "off".equals(value) );
                    return Mono.just("off".equals(value));
                })
                .onErrorResume(e -> {
                            log.info("Connection validation error: " + e.getMessage());
                            return Mono.just(false);
                        }
                )
                .doFinally(signalType -> connectionPool.close());
    }
}

3. Creamos nuestra clase HealthCheck

@Component("HealthCheckWriderRds")
@RequiredArgsConstructor
public class HealthCheck implements HealthIndicator {

    private final ConnectionPoolValidator connectionPoolValidator;

    @Override
    public Health health() {
        if (!Boolean.TRUE.equals(connectionPoolValidator.validateConnection().blockFirst())) {
            return Health.down()
                    .withDetail("Error Code", "down").build();
        }
        return Health.up().build();
    }
} 

4. validamos que la siguiente url te responda , según sea tu caso

http://localhost:8080/actuator/health

5. configuramos el livenessProbe, la cual va reiniciar cuando el health , no sea valido .

apiVersion: v1
kind: Pod
metadata:
  labels:
    test: myimage
  name: liveness-http
spec:
  containers:
  - name: myimage 
    image: myimage:0.0.1
    args:
    - liveness
    livenessProbe:
      httpGet:
        path: actuator/health
        port: 8080
        httpHeaders:
        - name: Custom-Header
          value: Awesome
      initialDelaySeconds: 3
      periodSeconds: 3

El tiempo puede variar según tu configuración y lo que demore el Failover, también se recomienda agregar -Dsun.net.inetaddr.ttl=0 se utiliza en aplicaciones Java para configurar el tiempo de vida (TTL, por sus siglas en inglés) de las entradas de caché del sistema de nombres de dominio (DNS).

happy code :).

Reference:

https://www.baeldung.com/spring-boot-health-indicators

Cuando esta trabajando con Linux un tiene que cambiar la Ip local, por algún ajuste de interfaz de red y normal mente uno reinicia, para poder evitar el reinicio podrías usar el siguiente comando para poder cambiar la Ip usando el cliente dhcp.

  sudo dhclient

dhclient es el software cliente DHCP. Cuando un equipo (cliente) se conecta a una red, puede usar dhclient para obtener automáticamente información de configuración, como dirección IP, máscara de subred, puerta de enlace predeterminada y servidores DNS, desde un servidor DHCP.

Cuando se ejecuta dhclient, envía un mensaje DHCPDISCOVER por difusión en la red, solicitando información de configuración. Un servidor DHCP responde con un mensaje DHCPOFFER que contiene una dirección IP y otras configuraciones de red. El cliente (usando dhclient) luego envía un DHCPREQUEST para aceptar la configuración ofrecida. Finalmente, el servidor DHCP reconoce (DHCPACK) la solicitud del cliente, y el cliente configura su interfaz de red con los ajustes proporcionados.

DHCP se utiliza comúnmente en redes donde las direcciones IP se asignan dinámicamente (en lugar de ser estáticas), permitiendo una gestión y asignación eficientes de direcciones IP.

dhclient lee su configuración desde /etc/dhcp/dhclient.conf, donde se pueden especificar opciones adicionales y parámetros sobre cómo debe comportarse el cliente y qué información debe solicitar al servidor DHCP.

En el mundo de la programación reactiva, Spring WebFlux ha surgido como una poderosa herramienta para construir aplicaciones robustas y eficientes. En esta guía, exploraremos cómo conectar Reader y Writer a una base de datos relacional (RDS) utilizando Spring WebFlux.

La interacción fluida entre la capa de lectura y escritura es fundamental para el desarrollo de aplicaciones de alta calidad. En este contexto, aprovechar la capacidad de WebFlux para gestionar operaciones de entrada y salida de manera reactiva puede marcar la diferencia en el rendimiento y la escalabilidad de tu aplicación.

Desde la configuración inicial hasta la implementación práctica, te guiaremos a través de los pasos necesarios para integrar eficazmente Reader y Writer con tu base de datos relacional utilizando Spring WebFlux. Prepárate para sumergirte en un viaje de descubrimiento mientras desbloqueamos los secretos de esta potente combinación tecnológica.

Para este ejemplo vamos a usar scaffold-clean-architecture para seguir patrón de desarrollo de buenas practicas, la cual no va ser una limitante si se implementa en otros patrones.

1. Creamos 2 paquetes uno para Writer y para Reader

Writer -> co.ncleguizamon.posgres.r2dbc-postgresql

Reader -> co.ncleguizamon.posgres.r2dbc-postgresql-reader

para el caso de clean architecture seria generar dos Driven Adapter por comandos

Writer

   gradle generateDrivenAdapter --type=r2dbc
   

Reader

   gradle generateDrivenAdapter --type=generic --name=r2dbc-postgresql-reader 
   

2. Crear bean

@Bean
    @Profile("local")
    public SecretPostgres secretsModelLocal(PostgresqlConnectionProperties postgresqlProperties) {
        return SecretPostgres.builder()
                .dbname(postgresqlProperties.getDatabase())
                .host(postgresqlProperties.getHost())
                .password(postgresqlProperties.getPassword())
                .username(postgresqlProperties.getUsername())
                .port(postgresqlProperties.getPort())
                .schema(postgresqlProperties.getSchema())
                .urlReaderRds(postgresqlProperties.geturlReaderRds())
                .build();
    }   

1. En cada paquete creamos nuestra configuración de nuestra carpeta de config

y una clase de configuración, en este caso llamada Config.java

Writer

@Configuration
@AllArgsConstructor
@EnableConfigurationProperties({PostgresqlConnectionProperties.class})
@EnableR2dbcRepositories(basePackages = "co.ncleguizamon.posgres.r2dbc-postgresql", entityOperationsRef = "postgresEntityTemplate")
public class Config {
    public static final int INITIAL_SIZE = 1;
    public static final int MAX_SIZE = 2;
    public static final int MAX_IDLE_TIME = 30;

    SecretPostgres secretPostgres;

    @Bean
    public R2dbcEntityOperations postgresEntityTemplate(
            @Qualifier("postgresConnection") ConnectionFactory connectionFactory) {
        DatabaseClient databaseClient = DatabaseClient.create(connectionFactory);
        return new R2dbcEntityTemplate(databaseClient, PostgresDialect.INSTANCE);
    }

    @Bean(name = "postgresConnection")
    public ConnectionPool getConnectionConfig() {
        PostgresqlConnectionConfiguration dbConfiguration = PostgresqlConnectionConfiguration.builder()
                .host(secretPostgres.getHost())
                .port(secretPostgres.getPort())
                .database(secretPostgres.getDbname())
                .schema(secretPostgres.getSchema())
                .username(secretPostgres.getUsername())
                .password(secretPostgres.getPassword())
                .build();

        ConnectionPoolConfiguration poolConfiguration = ConnectionPoolConfiguration.builder()
                .connectionFactory(new PostgresqlConnectionFactory(dbConfiguration))
                .name("api-postgres-connection-pool")
                .initialSize(INITIAL_SIZE)
                .maxSize(MAX_SIZE)
                .maxIdleTime(Duration.ofMinutes(MAX_IDLE_TIME))
                .validationQuery("SELECT 1")
                .build();

        return new ConnectionPool(poolConfiguration);
    
    // opcinal si usas 

    @Bean
    public TransactionalOperator transactionalOperator(
            @Qualifier("postgresConnection") ConnectionFactory connectionFactory) {
        return TransactionalOperator.create(new R2dbcTransactionManager(connectionFactory));
    }
}   

PostgresqlConnectionProperties.java

@Data
@ConfigurationProperties(prefix = "spring.r2bdc-postgres")
public class PostgresqlConnectionProperties {

    private String database;
    private String schema;
    private String username;
    private String password;
    private String host;
    private String urlReaderRds;
    private Integer port;
    

}
   

Reader

@Configuration
@AllArgsConstructor
@EnableR2dbcRepositories(basePackages = "co.ncleguizamon.posgres.r2dbc-postgresql-reader",
        entityOperationsRef = "postgresReaderEntityTemplate")
public class Config{
    public static final int INITIAL_SIZE = 3;
    public static final int MAX_SIZE = 6;
    public static final int MAX_IDLE_TIME = 30;

    SecretPostgres secretPostgres;

    @Bean
    public R2dbcEntityOperations postgresReaderEntityTemplate(
            @Qualifier("postgresReaderConnection") ConnectionFactory connectionFactory) {
        DatabaseClient databaseClient = DatabaseClient.create(connectionFactory);
        return new R2dbcEntityTemplate(databaseClient, PostgresDialect.INSTANCE);
    }

    @Bean(name = "postgresReaderConnection")
    public ConnectionPool getConnectionConfig() String urlReaderRds) {
        PostgresqlConnectionConfiguration dbConfiguration = PostgresqlConnectionConfiguration.builder()
                .host(secretPostgres.urlReaderRds == null? secretPostgres.getHost(): secretPostgres.urlReaderRds)
                .port(secretPostgres.getPort())
                .database(secretPostgres.getDbname())
                .schema(secretPostgres.getSchema())
                .username(secretPostgres.getUsername())
                .password(secretPostgres.getPassword())
                .build();

        ConnectionPoolConfiguration poolConfiguration = ConnectionPoolConfiguration.builder()
                .connectionFactory(new PostgresqlConnectionFactory(dbConfiguration))
                .name("api-postgres-connection-pool-reader")
                .initialSize(INITIAL_SIZE)
                .maxSize(MAX_SIZE)
                .maxIdleTime(Duration.ofMinutes(MAX_IDLE_TIME))
                .validationQuery("SELECT 1")
                .build();

        return new ConnectionPool(poolConfiguration);
    }
   

@EnableR2dbcRepositories

@EnableR2dbcRepositories se utiliza para habilitar los repositorios de Spring Data R2DBC para el paquete base especificado (com.example.repository). Spring generará automáticamente implementaciones para las interfaces de repositorio que se encuentren en este paquete, lo que te permitirá usarlas en tu aplicación.

Asegúrate de haber incluido las dependencias necesarias en tu proyecto para usar Spring Data R2DBC, como spring-boot-starter-data-r2dbc si estás utilizando Spring Boot.

entityOperationsRef

Referencia del bean que hace referencia a R2dbcEntityOperations, según sea el repository, configurado .

Para usar cada uno de los dos paquetes , debes implementar unas interface por cada uno de los paquetes , para poder usarlos en tus casos de uso , ejemplo.

Reader , solo lecturas

public interface UserReaderService {


    Flux<User> findByAllId(Long id);

    Flux<User>  getList(Long id);
    ....

}

   

Writer , updates , create , delete

public interface UserWriterService {


    Mono<User> deleteById(Long id);
    Mono<User> create(Long id);

    .....
    
}

   

Implementa en tu Adapter, según sea el caso.

@Repository
@RequiredArgsConstructor
public class UserRepositoryAdapter implements UserReaderService {
// repository en el paquete postgresReaderEntityTemplate
    private final UserDataRepository userDataRepository;


    ....


    
   

recuerda si usas jpa debes usar @EnableJpaRepositories

Reference:

EnableR2dbcRepositories (Spring Data R2DBC 3.2.5 API)

declaration: package: org.springframework.data.r2dbc.repository.config, annotation type: EnableR2dbcRepositories

Repositories cannot be used with two different database systems · Issue #406 · spring-projects/spring-data-r2dbc

There is a conflict with methods query generator in repository when you have 2 different database servers mssql and mysql at the same time. And it renders query with dialect of only certain databas…

GitHubspring-projects

R2dbcEntityTemplate es un componente central de Spring Data R2DBC que simplifica el acceso a la base de datos y la manipulación de datos al proporcionar una API reactiva de alto nivel para interactuar con una base de datos relacional. Sigue el patrón de plantilla (template pattern), donde maneja las operaciones comunes de la base de datos, como la inserción, actualización, eliminación y consulta de datos, lo que te permite centrarte en la lógica de negocio de tu aplicación.

Para testear una clase que implemente R2dbcEntityTemplate lo vamos hacer con junit .

Ejemplo:

Clase java TestAdapter

@Repository
@RequiredArgsConstructor
public class TestAdapter implements TestService {

    private final R2dbcEntityTemplate template;
    @Override
    public Mono<Void> delete(Test test) {
        return template.delete(TestData.class)
                .matching(
                        Query.query(Criteria.where("id").is(test.getId())
                                .and(STATE).is(test.getState())
                                .and(CONSECUTIVE).is(test.getConsecutive())
                        )

                )
                .all().then();
    }
    @Override
    public Mono<Void> update(Test test) {
       return template.update(TestData.class)
         .matching(
                    Query.query(Criteria.where(ID).is(test.getT1())))
               .apply(Update.update(CONSECUTIVE, test.getT2())
               )
               .then();
    }
    

}

Clase java TestAdapterTest

moqueamos R2dbcEntityTemplate

   private final R2dbcEntityTemplate template
            = Mockito.mock(R2dbcEntityTemplate.class, RETURNS_DEEP_STUBS);
            
            
            
            // example test
          @Test
    void delete(){     
    Mockito.when(template.delete(TestData.class)
    .matching(any(Query.class)).all())
                .thenReturn(Mono.empty());

        TestAdapter.delete(test)
                .as(StepVerifier::create)
                .verifyComplete();
    }      
            

update

   private final R2dbcEntityTemplate template
            = Mockito.mock(R2dbcEntityTemplate.class, RETURNS_DEEP_STUBS);
            
            
            
            // example test update
          @Test
    void update(){     
   
        Mockito.when(template.update(TestData.class)
        .matching(any(Query.class)).apply(any()))
                .thenReturn(Mono.empty());

        TestAdapter.update(tets)
                .as(StepVerifier::create)
                .verifyComplete();
    }      
            

happy code :).

Cuando esta trabajando con Sprint webflux , necesitas subir archivos a tu aplicación puedes usar los BodyExtractors.toMultipartData() , lo cuales te permitirán obtener los archivos enviados por la api y con una función puedes extraer  los byte[] de un archivo de tipo FilePart.

Ejemplo :

 private  Mono<data> getFile(ServerRequest serverRequest){
        return serverRequest.body(BodyExtractors.toMultipartData())
                .flatMap(parts -> {
                    Map<String, Part> part = parts.toSingleValueMap();
                    return Mono.just((FilePart) part.get("file"));
                })
                .flatMap(filePart -> {
                    Mono<byte[]> dataStreamFile =      validateContent(filePart.content());
                    
                    return  dataStreamFile;
                })
                .flatMap(data );
    }
    
       private Mono<byte[]> validateContent(Flux<DataBuffer> file) {
        return file.single().map(dataBuffer -> {
            if (dataBuffer.readableByteCount() <= ZERO) {
                throw new IllegalArgumentException("error no records were found in the file");
            }
            if (dataBuffer.readableByteCount() > MAX_FILE_SIZE) {
                throw new IllegalArgumentException("error while loading file, exceeds the allowed upload capacity");
            }
            byte[] bytes = new byte[dataBuffer.readableByteCount()];
            dataBuffer.read(bytes);
            return bytes;
        }).onErrorMap(throwable -> new RuntimeException("Error process file content"));
    }

Para los test unitarios, puedes importar el archivo en byte[] y lo asignas al MultipartBodyBuilder , con el nombre del  Part que vas a extraer en tu función.

Ejemplo:

MultipartBodyBuilder builder  = new MultipartBodyBuilder();
        builder.part("file", bytes,MediaType.MULTIPART_FORM_DATA)
                .header("Content-Disposition", "form-data; name=file; filename=prueba.xlsx");     

y despues se lo asignas al body de tu test unitario.

Ejemplo.

    WebTestClient webTestClient;
   @Test
    void validateMultiple() throws URISyntaxException, IOException {

        byte[] bytes = Files.readAllBytes(Paths.get(getClass().getClassLoader()
                .getResource("prueba.xlsx").toURI()));

        MultipartBodyBuilder builder  = new MultipartBodyBuilder();
        builder.part("file", bytes,MediaType.MULTIPART_FORM_DATA)
                .header("Content-Disposition", "form-data; name=file; filename=prueba.xlsx");

      
        webTestClient.post().uri(uriBuilder -> uriBuilder
                        .path(BASE_ROUTE+ "/upload")
                        .build())
                .contentType(MediaType.MULTIPART_FORM_DATA)
                .body(BodyInserters.fromMultipartData(builder.build()))
                .exchange()
                .expectStatus()
                .isOk();
    }

happy code :).

Referencias:

https://www.javadoc.io/doc/org.springframework/spring-web/5.0.3.RELEASE/org/springframework/http/client/MultipartBodyBuilder.html

Azure devops nos permite llamar un api Rest para poder ejecutar cualquier funcionalidad de Azure devops y principalmente poder automatizar un despliegue en cierta hora y de forma automática por Azure pipelines.

1. Para poder ejecutar el api Rest tienes que generar un token de autenticación en la plataforma de Azure devops:

Te creas un nuevo token, puedes seleccionar los permisos que quieres ejecutar

Remplaza los siguientes valores y ejecuta el curl :

organization: El nombre de la organización de Azure DevOps.

project : ID del proyecto o nombre del proyecto

pipelineId : id del pipeline, lo puedes identificar en Azure devops, buscando el pipeline y el en la url, te sale definitionId.

TOKEN : token personal generado, en el paso 1.

curl --request POST \
  --url 'https://dev.azure.com/{organization}/{project}/_apis/pipelines/{pipelineId}/runs?api-version=7.0' \
  --header 'Authorization: Basic {TOKEN}' \
  --header 'Content-Type: application/json' \
  --data '{
	"definitionId": "{pipelineId}",
	"templateParameters": {
		"key": "Value", 
		
	}
}'

templateParameters, son los parámetros que tenga el pipeline según sea el caso.

Revisa que el pipeline se este ejecutando.

Referencias:

Runs - Run Pipeline - REST API (Azure DevOps Pipelines)

Learn more about Pipelines service - Runs a pipeline.

Microsoft Learnwnjenkin

Unos de los principales problemas que se tiene a la hora de querer implementar la ultima versión de apache camel es no tener una buena documentación o si la hay no hay ejemplos funcionales, primero hay que tener en cuenta que vamos a trabajar con la version apache camel-core  3.18.0 y de aws v2 2.17.232.

Es muy importante la compatibilidad entre versiones, porque te puede dar muchos errores.

Dependencias java

<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<aws.sdk2.version>2.17.232</aws.sdk2.version>
	</properties>
<dependencyManagement>
	<dependencies>

	<dependency>
		<groupId>software.amazon.awssdk</groupId>
		<artifactId>bom</artifactId>
		<version>${aws.sdk2.version}</version>
		<type>pom</type>
		<scope>import</scope>
	</dependency>
	</dependencies>
	</dependencyManagement>


<dependencies>
		<dependency>
			<groupId>org.apache.camel</groupId>
			<artifactId>camel-core</artifactId>
			<version>3.18.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.apache.camel/camel-aws2-sqs -->
		<dependency>
			<groupId>org.apache.camel</groupId>
			<artifactId>camel-aws2-sqs</artifactId>
			<version>3.18.0</version>
		</dependency>


		<!-- use the same version as your Camel core version -->
		<dependency>
			<groupId>software.amazon.awssdk</groupId>
			<artifactId>sqs</artifactId>
		</dependency>


		<!-- logging -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.7.7</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.7</version>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>

	</dependencies>

En el siguiente fragmento de código, creamos el client de aws sqs , y se lo asignamos al contexto de de camel.

MainApp.java

public class MainApp {
    public static void main(String... args) throws Exception {
    // create aws sqs client
        SqsClient sqsClient = SqsClient.builder()
                .region(Region.US_EAST_1).build();
            DefaultCamelContext ctx = new DefaultCamelContext();

            try {
                ctx.getRegistry().bind("sqsClient", sqsClient);
                ctx.addRoutes(new SQSRouteBuilder());

                ctx.start();

                Thread.sleep(60 * 60 * 1000);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
}

A continuación vamos a configurar el comportamiento, para obtener los mensajes del sqs.

SQSRouteBuilder.java

public class SQSRouteBuilder extends RouteBuilder {
	public void configure() {


		from("aws2-sqs://demo-camel-test?amazonSQSClient=#sqsClient")
				.log("Processing ..... ${body}")
				.to("mock:result")
	}
}

Notas:  

• Revisa  las versiones de compatibilidad entre versiones del core de camel y de aws o de los .jar que uses.
• Coloca en tu maquina unas credenciales validas para que te puedas conectar a las colas de sqs
• Si necesitas registrar componentes en la versión de camel core   3.18.0 , debes hacerlo con el  Register ejemplo

MQQueueConnectionFactory mqQueueConnectionFactory = new MQQueueConnectionFactory();
// configuration ibm mq 
  ctx.getRegistry().bind("mq", JmsComponent.jmsComponentAutoAcknowledge(mqQueueConnectionFactory));

Referencias:

Apache Camel helps you integrate over 300 different systems!

Apache Camel ™ is a versatile open-source integration framework based on known Enterprise Integration Patterns. Camel empowers you to define routing and mediation rules in a variety of domain-specific languages, including a Java-based Fluent API, Spring or Blueprint XML Configuration files, and a Sc…

Apache Camel

Running Apache Camel standalone

How to run Apache Camel in a standalone Java app

Tom DonohueTom Donohue

Cuando estas testeando código que por alguna razón dependa de alguna variable de entorno o Properties en java puedes usar junit-jupiter.

Variable que se quiere mockear en  java

 String testVarible = System.getenv("testVarible");

Dependencies

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.8.1</version>
    <scope>test</scope>
</dependency>

Ejemplo:

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.extension.ExtendWith;


import org.junit.jupiter.api.Test;
import uk.org.webcompere.systemstubs.environment.EnvironmentVariables;
import uk.org.webcompere.systemstubs.jupiter.SystemStub;

@ExtendWith(SystemStubsExtension.class)
public class test {
    @SystemStub
    private static EnvironmentVariables environmentVariables=new EnvironmentVariables();


    @BeforeAll
    public static void beforeAll() {
        environmentVariables.set("testVarible", "value1");
    }
    
      @Test
    public void TestEven1() throws FileNotFoundException {
    
            environmentVariables.set("testVarible",  "EstaEsMiVariable");

    
    }

si usas JUnit 4 podrías usar

Crea variables de entorno para test junit java

Agrega variables de entorno para test junit java.

ncleguizamonNestor Camilo Leguizamón

happy code :).

Referencia

https://junit.org/junit5/docs/current/user-guide/

https://www.baeldung.com/java-system-stubs

Unos de los principales problemas que se tiene cuando comienzas con glue aws es como puedes probar sin tener que desplegar en la consola de aws la cual puede ser compleja y los logs no se pueden visualizar de manera fácil, para poder comprender como funciona tu script.

Aws nos provee una opcion para poder desarrollar localmente con docker usando una imagen que esta en docker hub  amazon/aws-glue-libs:glue_libs_3.0.0_image_01 y la ejecución del contenedor en un equipo local (Mac/Windows/Linux). Esta imagen de contenedor ha sido probada para detectar trabajos de versión 3.0 de Spark de AWS Glue.

Esta imagen contiene lo siguiente:

• Amazon Linux
• Biblioteca de ETL de AWS Glue (aws-glue-libs)
• Apache Spark 3.1.1
• Servidor de historial de Spark
• Laboratorio de Jupyter
• Livy
• Otras dependencias de biblioteca ( AWS Glue)

Configuracion

docker pull amazon/aws-glue-libs:glue_libs_1.0.0_image_01

Levantar contenedor Jupyter notebooks

docker run -itd -p 8888:8888 -p 4040:4040 -v ~/.aws:/root/.aws:ro --name glue_jupyter \amazon/aws-glue-libs:glue_libs_1.0.0_image_01 \
/home/jupyter/jupyter_start.sh

spark-submit

Puede ejecutar un script de trabajo de AWS Glue ejecutando el comando spark-submit en el contenedor, puedes ejecutar tus scripts

$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_spark_submit amazon/aws-glue-libs:glue_libs_3.0.0_image_01 spark-submit /home/glue_user/workspace/src/$SCRIPT_FILE_NAME
...22/01/26 09:08:55 INFO DAGScheduler: Job 0 finished: fromRDD at DynamicFrame.scala:305, took 3.639886 s
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- lang: string
| | |-- note: string
| | |-- name: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string

...

Referencia

https://noise.getoto.net/2020/09/21/building-an-aws-glue-etl-pipeline-locally-without-an-aws-account/

Desarrollo y pruebas de scripts de trabajo de AWS Glue - AWS Glue

Utilice la biblioteca Scala de AWS Glue disponible públicamente para desarrollar y probar localmente sus scripts de ETL de Python o Scala.

AWS Glue

Unos de los principales problemas a la hora de instalar sonarqube en tu maquina local con docker nos sale el siguiente error, o por problema de memoria

app[][o.s.a.ProcessLauncherImpl] Launch process[[key='es', ipcIndex=1, logFilenamePrefix=es]] from [/opt/sonarqube/elasticsearch]: /opt/sonarqube/elasticsearch/bin/elasticsearch

se puede arreglar con docker compose  

Creamos los directorios

 
mkdir -p ./sonarqube/data
mkdir -p ./sonarqube/extensions
mkdir -p ./sonarqube/logs
mkdir -p ./postgresql/conf
mkdir -p ./postgresql/data

Creamos dos archivos

 
├── docker-compose.yml
├── init.sh

modificamos el archivo docker-compose.yml

version: "3.7"
services:
  sonarqube:
    image: sonarqube:8.9.7-community
    depends_on:
      - db
    environment:
      SONAR_JDBC_URL: jdbc:postgresql://db:5432/sonar
      SONAR_JDBC_USERNAME: sonar
      SONAR_JDBC_PASSWORD: sonar
    
    volumes:
      
      - type: bind
        source: ./sonarqube/data
        target: /opt/sonarqube/data
      - type: bind
        source: ./sonarqube/extensions
        target: /opt/sonarqube/extensions
      - type: bind
        source: ./sonarqube/logs
        target: /opt/sonarqube/logs
    ports:
      - "9000:9000"
  init:
      image: bash
      privileged: true
      user: root
      volumes:
        - ./init.sh:/mnt/init.sh 
      command: ["sh", "-e", "/mnt/init.sh"]
  db:
    image: postgres:12
    environment:
      POSTGRES_USER: sonar
      POSTGRES_PASSWORD: sonar
    volumes:
      - type: bind
        source: ./postgresql/conf
        target: /var/lib/postgresql
      - type: bind
        source: ./postgresql/data
        target: /var/lib/postgresql/data

modificamos el archivo init.sh

sysctl -w vm.max_map_count=524288
sysctl -w fs.file-max=131072

Ejecutamos en la terminal

docker-compose up -d

Verificamos que estén corriendo los dos contenedores

docker container ls
CONTAINER ID        IMAGE                       COMMAND                  CREATED             STATUS              PORTS                    NAMES
5deca7c22ea4        sonarqube:8.9.7-community   "bin/run.sh bin/sona…"   20 hours ago        Up 39 seconds       0.0.0.0:9000->9000/tcp   sonar_sonarqube_1
ca515bffb4bb        postgres:12                 "docker-entrypoint.s…"   20 hours ago        Up 40 seconds       5432/tcp                 sonar_db_1

Referencia:

https://hub.docker.com/_/sonarqube

how can docker-compose run comands as no-root user

how can docker-compose run comands as no-root user? My docker-compose.yml just show below:version: "3"services: sonarqube-h: image: sonarqube:community user: "${UID}:${G...

Stack Overflowcao ting

Para resolver el problema, intenté agregar "registros A" para el dominio de ápice "test.com" junto con el subdominio de primer nivel "prod.test.com" y el subdominio de segundo nivel "auth.prod.test.com".

Esto creó el dominio personalizado requerido "dev.auth.prod.test.com" en el grupo de usuarios de manera apropiada. Además de esto, probé otro escenario en el que eliminé los "registros A" para el dominio apex "test.com" y el primer nivel subdominio "prod.test.com" y se registra un recorpset  "registros A" para el subdominio de segundo nivel "auth.prod.test.com" solamente , se pudo crear el dominio.

para validar

But if we do
$ dig A auth.prod.test.com +short

para concluir si nesecitas un dominio dev.auth.prod.test.com necesitas un recorpset de tipo A , al sub dominio auth.prod.test.com, puede ser cualquier ip, lo importante es que exista el registro de tipo A.

happy code .

Unos de los principales problemas que se tiene con lambdas aprovisionadas es su alto costo el cual podría llegar a ser demasiado alto.

El el post anterior les mostré como se proporcionaba con ApplicationAutoScaling de amazon

Provisioned Concurrency for Lambda Functions

Aprovisiona funciones lambdas con políticas de escalado según la concurrencia en aws.

ncleguizamonNestor Camilo Leguizamón

hay una sesión de AWS::ApplicationAutoScaling::ScalableTarget el cual se llama  ScheduledActions, el cual nos permite ejecutar acciones automáticas cada cierto tiempo y modificar nuestro aprovisionamiento, por ejemplo un aprovisionamiento como una desaprovechamiento después de cierta hora.

  ..............
  
   ScheduledActions:                                  
        - ScalableTargetAction:
            MinCapacity: 5
            MaxCapacity: 5
          Schedule: 'cron(0 30 17 * * ?)'
          #Schedule: rate(10 minutes)
          ScheduledActionName: scale-out
          Timezone: "America/Bogota"
        - ScalableTargetAction:
            MinCapacity: 0
            MaxCapacity: 0
          Schedule: 'cron(0 50 7 * * ?)'
          #Schedule: rate(5 minutes)
          ScheduledActionName: scale-in
          Timezone: "America/Bogota"
          
  ..................

pueden consultar la información oficial en https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-applicationautoscaling-scalabletarget-scheduledaction.html

Ejemplo de template Cloudformation:

AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
Description: Escalin api 


Parameters: 
  LambdaFunction:
    Type: String
    Default: "CreateOrder"
  


Resources:
  lambdaByScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Condition: CognitoLambdaTriggerActivateAutoscaling
    Properties:
      MaxCapacity: 0
      MinCapacity: 0
      ResourceId: !Sub function:${LambdaFunction}:production # You need to specify an alis or version here
      RoleARN: !Sub arn:aws:iam::${AWS::AccountId}:role/aws-service-role/lambda.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_LambdaConcurrency
      ScalableDimension: lambda:function:ProvisionedConcurrency
      ServiceNamespace: lambda
      ScheduledActions:                                  
        - ScalableTargetAction:
            MinCapacity: 5
            MaxCapacity: 5
          Schedule: 'cron(0 30 17 * * ?)'
          #Schedule: rate(10 minutes)
          ScheduledActionName: scale-out
          Timezone: "America/Bogota"
        - ScalableTargetAction:
            MinCapacity: 0
            MaxCapacity: 0
          Schedule: 'cron(0 50 7 * * ?)'
          #Schedule: rate(5 minutes)
          ScheduledActionName: scale-in
          Timezone: "America/Bogota"
      SuspendedState:
        DynamicScalingInSuspended: false
        DynamicScalingOutSuspended: false
        ScheduledScalingSuspended: false

  lambdaTargetTrackingScalingPolicy:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: utilization
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref TriggerByScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 0.7
        PredefinedMetricSpecification:
          PredefinedMetricType: LambdaProvisionedConcurrencyUtilization

para ver las actividades que se han ejecutado en las lambda

aws application-autoscaling describe-scaling-activities \
--service-namespace lambda \
--scalable-dimension lambda:function:ProvisionedConcurrency \
--resource-id function:CreateOrder:prod

{
    "ScalingActivities": [
        {
            "ActivityId": "6d2bf4ed-6eb5-4218-b4bb-f81fe6d7446e",
            "ServiceNamespace": "lambda",
            "ResourceId": "function:CreateOrder:prod",
            "ScalableDimension": "lambda:function:ProvisionedConcurrency",
            "Description": "Setting desired concurrency to 0.",
            "Cause": "maximum capacity was set to 0",
            "StartTime": 1596374119.716,
            "EndTime": 1596374155.789,
            "StatusCode": "Successful",
            "StatusMessage": "Successfully set desired concurrency to 0. Change successfully fulfilled by lambda."
        },
        {
            "ActivityId": "2ea46a62-2dbe-4576-aa42-0675b6448f0a",
            "ServiceNamespace": "lambda",
            "ResourceId": "function:CreateOrder:prod",
            "ScalableDimension": "lambda:function:ProvisionedConcurrency",
            "Description": "Setting min capacity to 0 and max capacity to 0",
            "Cause": "scheduled action name scale-in was triggered",
            "StartTime": 1596374119.415,
            "EndTime": 1596374119.431,
            "StatusCode": "Successful",
            "StatusMessage": "Successfully set min capacity to 0 and max capacity to 0"
        },
----------------------------

happy code .

Referencia:

Scheduling AWS Lambda Provisioned Concurrency for recurring peak usage | Amazon Web Services

This post is contributed by Jerome Van Der Linden, AWS Solutions Architect Concurrency of an AWS Lambda function is the number of requests it can handle at any given time. This metric is the average number of requests per second multiplied by the average duration in seconds. For example, if a Lambda…

Amazon Web ServicesChris Munns

AWS::AutoScaling::ScheduledAction - AWS CloudFormation

Use the AWS CloudFormation AWS::AutoScaling::ScheduledAction resource for AutoScaling.

AWS CloudFormation

Jenkins nos permite automatizar y parametrizar nuestros despliegues de una forma muy sencilla y fácil , pero últimamente he estado utilizando plantillas de terceros los cuales no puedo acceder al código fuente y agregarle parámetros por lo cual  no me permite ser dinámico y me a limitado y para hacer diferentes despliegues tengo que modificar directamente el el repositorio.

Por lo cual e estado buscando una manera que me permita ingresar dichos parámetros de forma dinámica, lo primero que se identifico es que no se debe usar la estructura básica del pipeline e jenkins sino usar  un archivo groovy .

.......

node() {
    properties([
        parameters([
        booleanParam(
            defaultValue: false,
            description: 'isFoo should be false',
            name: 'isFoo'
        ),
        stringParam(
            defaultValue: "Nestor",
            description: 'Name user',
            name: 'Name'
        ),
           ])

    ])
    print "DEBUG: parameter isFoo = ${params.isFoo}"
   sh "echo sh isFoo is ${params.isFoo}"
    
//Comandos de template 
.....
}

Para obtener o usar los parámetros los podemos usar como hacemos en un pipeline normal ejemplo ${params.isFoo} .

Opciones de parámetros

Nota: la lista anterior solo son unos de los que encontrado y probado.

Referencia

How to access parameters in a Parameterized Build?

How do you access parameters set in the “This build is parameterized” section of a “Workflow” Jenkins job? TEST CASE Create a WORKFLOW job.Enable “This build is parameterized”.Add a STRING PAR...

Stack OverflowVizionz

Pipeline: Groovy

Jenkins – an open source automation server which enables developers around the world to reliably build, test, and deploy their software

Pipeline: Groovy