fbpx

Versionado de esquemas de bases de datos y migraciones simplificadas para CI/CD de alta velocidad – PARTE 2

Tal como se comentó hace unos días, les hacemos entrega de la segunda parte de este interesante articulo sobre versionas de esquemas de base de datos. Si te perdiste la primera parte de este articulo, puedes verlo aquí.

Avanzado

Aquí puedes encontrar algunas funciones clave, como parámetros de registros de cambios, etiquetas de columna y de condiciones previas.

1. Condiciones previas

Si solo quieres aplicar un registro o conjunto de cambios bajo ciertas condiciones, necesitas usar la etiqueta de condición previa. Hay muchos tipos diferente. Puedes encontrarlos aquí.

Si la condición previa no es válida, puedes detener la actualización, omitir un conjunto de cambios, marcar un conjunto de cambios como ejecutado o mostrar una advertencia.

2. Extensión de Liquibase

Si no quieres usar los formatos SQL, XML, YAML o JSON para tu registro de cambios, puedes utilizar la extensión de Liquibase para crearlo en el formato que prefieras.

Integración

Liquibase se integra de forma fácil en tu aplicación Java, si usas Spring o Spring Boot.

Spring

Si quieres ejecutar los cambios en la startup de la aplicación Spring, usa el siguiente Spring Bean:

@Bean

public SpringLiquibase liquibase() {

SpringLiquibase liquibase = new SpringLiquibase();

liquibase.setchangelog(«classpath:db/changelog/db.changelog-master.xml»);

liquibase.setDataSource(dataSource());

return liquibase;

}

Nota: db/changelog/db.changelog-master.xml debe existir previamente en la carpeta src/main/resources.

Spring Boot 2

Si usas Spring Boot, no hay necesidad de definir una Bean para Liquibase.

Todo lo que tienes que hacer es cambiar el valor de spring.liquibase.change-log en el archivo src/main/resources/application.properties de Spring, y las migraciones de Liquibase se ejecutarán automáticamente en la startup de la aplicación:

spring.liquibase.change-log=classpath:/db/changelog/db.changelog-master.xml

Nota: El valor por defecto es classpath:/db/changelog/db.changelog-master.yaml. Puedes encontrar todas las propiedades de Spring Boot para Liquibase aquí.

Test

Test unitario

Para los tests unitarios, no necesitas utilizar Liquibase, al no requerir interacción con la base de datos.

Si usas Spring Boot, desactiva Liquibase y Spring Data Source de esta forma:

spring.liquibase.enabled=false

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration, \

org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration, \

org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration, \

org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration

Test de integración

Hay varias maneras de almacenar tu información de tests. Puedes:

  • Crear un registro de cambios para el test (almacenado en src/test/resources), y señalarlo en la configuración de Spring para la prueba, para almacenar la información en la inicialización de Liquibase. Pero en cada modificación de la base de datos tendrás que cambiar los registros de cambios de prueba.
  • Usar las anotaciones de Spring y los script SQL para almacenar la información en la inicialización de Spring. Pero al igual que en la primera solución, necesitas modificar los scripts SQL cada vez que se cambie el modelo de datos.
  • Definir todas las operaciones en cada test usando los repositorios (Liquibase carga el esquema de la base de datos en la inicialización de Spring)
Contenido Relacionado:  8 lenguajes de programación para aprender a programar desde cero

@ExtendWith(SpringExtension.class)

public class AnimalRepositoryTest {

    @Autowired

    private AnimalRepository animalRepository;

    @Autowired

    private OwnerRepository ownerRepository;

    @BeforeEach

    public void setUp() {

        animalRepository.deleteAll();

        ownerRepository.deleteAll();

    }

    @Test

    public void findByName_should_return_the_right_animal() throws Exception {

        // Given

        final Owner owner = ownerRepository.save(new Owner(«Céline»));

        final Animal animal = animalRepository.save(new Animal(«Peluche», owner));

        // When

        final Animal result = animalRepository.findByName(«Peluche»);

        // Then

        assertEquals(animal, result);

    }

}

Esta solución es más rimbombante, pero también más fácil de leer (y no necesita encontrar todos los datos de prueba en los archivos SQL/de registro de cambios). Es así mismo más fácil de mantener, ya que, si el modelo de datos cambia, lo verás en tu IDE o durante la fase de recopilación de los tests.

Herramientas

Plugin de graduación

En vez de escribir el archivo de registro de cambios manualmente, usa el plugin de graduación de Liquibase para generar uno. Después, lo único que tienes que hacer es dividirlo.

1. Configuración del plugin

Añade el plugin de graduación al build.gradle:

id ‘org.liquibase.gradle’ version ‘2.0.2’

2. Genera un registro de cambios de 1 base de datos existente

Añade la configuración del plugin para la tarea generateChangeLog en el build.grade:

liquibase {

activities {

            main {

                        changeLogFile changeLog

                        url ‘jdbc:postgresql://localhost:5432/bonita’

                        username ‘%USER_NAME%’

                        password ‘%PASSWORD%’

            }

}

}

Después ejecuta la tarea ./gradlew generateChangeLog

Esto puede ser útil durante el desarrollo, si quieres dejar que Hibernate genere el esquema de la base de datos, y luego el registro de cambios desde la base de datos generada.

3. Genera un registro de cambios a partir de las diferencias entre 2 bases de datos existentes.

Añade la configuración del plugin para la tarea diff, en build.gradle:

Contenido Relacionado:  Etiqueta de Prioridad de Mapa de Sitio En Google Xml Sitemaps

liquibase {

activities {

            main {

                        changeLogFile changeLog

                        url ‘jdbc:postgresql://localhost:5432/bonita’

                        username ‘%USER_NAME%’

                        password ‘%PASSWORD%’

                        referenceUrl ‘jdbc:postgresql://localhost:5432/bonita_7.5’

                        referenceUsername ‘%USER_NAME%’

                        referencePassword ‘%PASSWORD%’

            }

}

}

Después ejecuta la tarea ./gradlew diff

Puedes comparar el esquema de una base de datos de producción con el de otra vacía recién instalada, si hay algún problema durante la migración de la base de datos de producción.

4. Comandos de la comunidad

Hay otras tareas de graduación para el plugin que puedes encontrar aquí.

Plugin Hibernate de Liquibase

Si la aplicación usa Hibernate, puedes usar este plugin de graduación para generar el registro de cambios desde tus entidades durante el desarrollo.

  1. Configuración del plugin

Añade el plugin de graduación en build.gradle:

compile group: ‘org.liquibase.ext’, name: ‘liquibase-hibernate5’, versión: ‘3.10.0’

2. Genera un registro de cambios de las diferencias entre una base de datos y entidades de persistencia

Añade la configuración del plugin para la tarea dediffChangeLog en build.gradle:

liquibase {

activities {

            main {

                        changeLogFile changeLog

                        url ‘jdbc:postgresql://localhost:5432/bonita’

                        username ‘%USER_NAME%’

                        password ‘%PASSWORD%’

                        referenceUrl ‘hibernate:spring:com.example?dialect=org.hibernate.dialect.MySQL5Dialect&hibernate.physical_naming_strategy=org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy&hibernate.implicit_naming_strategy=org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy’

            }

}

}

Después ejecuta la tarea ./gradlew diffChangeLog

Conclusión

En este tutorial hemos visto varias funciones muy útiles de Liquibase, que te permiten evolucionar tu esquema de base de datos fácilmente en una aplicación de Java.

Versionar tu base de datos con Liquibase significa que puedes:

  • Refactorizar tu código fácilmente a la vez que tienes lanzamientos simples de producción (sin necesidad de ejecutar manualmente comandos SQL o desarrollar tu propia herramienta de migración, al estar terminada la actualización de la base de datos a la hora de lanzar la nueva versión de tu aplicación)
  • Probar de forma fácil el estado de tu base de datos (de forma local o en una integración continua)
  • Mejorar el trabajo en equipo, ya que los cambios son visibles y se pueden aplicar fácilmente por cualquier persona

La implementación de todos estos ejemplos puede encontrarse en mi proyecto de github.

Links

•             https://www.baeldung.com/liquibase-refactor-schema-of-java-app

•             https://blog.soat.fr/2015/10/liquibase-et-le-versioning-de-base-de-donnees

•             https://mvnrepository.com/artifact/org.liquibase/liquibase-core

•             https://www.liquibase.org/

Escritora del articulo:

Souchet Céline, ingeniera de I+D en Bonitasoft

Actualización

Si te perdiste la primera parte de este articulo, puedes verlo aquí.

Share
Avatar

Pablo J.

Desarrollador gráfico y web, con ganas de trabajar y aprender todo lo posible de este campo tan variado. Trato de ser creativo en la vida laboral como personal. Amante de la buena lectura, el cine con sentido e inteligente.

You may also like...

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *