Uno de los propósitos de QA es generar modelos que aporten consistencia y organización a la hora de trabajar en proyectos de automatización.

Si además queremos que este modelo se sustente en la unificación de las bases de proyectos, la opción es Maven. Dicho esto, la primera pregunta que puede surgir es, ¿y por qué no con Gradle?

Lo cierto es que, a pesar de que su uso parece estar generalizándose, la gran mayoría de los proyectos basados en automatización siguen usando Maven. Además cuenta con una documentación mucho más extensa. Siendo sinceros, aunque empieces a utilizar Gradle para la automatización, finalmente acabarás recurriendo a Maven.

En este post veremos cómo crear, configurar y distribuir artefactos de nuestros proyectos para mejorar los procesos de desarrollos futuros.

 

QUÉ ES MAVEN

En primer lugar debemos entender qué es Maven y el beneficio que nos aporta. Nuestra idea es usarlo para desplegar un artefacto.

Maven es una herramienta que nos simplificará los procesos de desarrollo de un proyecto. Una de las principales ventajas es tenerlo todo centralizado en un fichero llamado POM (Project Object Model), el cual nos aportará toda la información y configuración del proyecto.

Este fichero está dividido en diversas secciones, pero para nuestro propósito nos centraremos principalmente en dos:

  • Configuración de la construcción
  • Configuración del entorno

 

CONFIGURACIÓN DE LA CONSTRUCCIÓN

Contiene la configuración de los plugins e informes que usaremos durante el ciclo de vida de la construcción. Éste se divide en varias etapas con las que podemos alterar el comportamiento del proyecto:

  • Validación
  • Compilación
  • Test
  • Empaquetado
  • Test de integración
  • Verificación
  • Instalación
  • Despliegue

Estas fases tienen una ejecución lineal. Esto quiere decir que, siguiendo la lista anterior, si quisiéramos usar la fase de verificación, previamente Maven pasaría por todas las fases anteriores.

 

CONFIGURACIÓN DEL ENTORNO

Será la encargada de definir los entornos externos a nuestro proyecto que necesitaremos, y los perfiles o requisitos para diferentes configuraciones dentro del mismo entorno. Algunas de las posibles configuraciones son las siguientes:

  • Distribuciones
  • Incidencias
  • Integración continua
  • Cadena de suministros
  • Prerrequisitos
  • Repositorios
  • Perfiles

 

 

QUÉ ES UN ARTEFACTO

A grandes rasgos, un artefacto es un conjunto de funciones, acciones y servicios que almacenamos conjuntamente en un único lugar para que cualquier persona pueda disponer de ellos y poder usarlos.

Así conseguimos tener un proyecto modularizado que nos permita beneficiarnos de todo lo creado. Además, si requerimos de una actualización o necesitamos añadir nuevos artefactos, el impacto de los cambios sobre nuestro proyecto será muy bajo.

 

 

CONFIGURAR UN ARTEFACTO

Para poder llevar a cabo el despliegue de un artefacto, debemos configurar nuestro POM del proyecto siguiendo el siguiente modelo.

A continuación, planteamos un ejemplo de los pasos a seguir para configurar un artefacto que posteriormente pueda ser usado.

 

CONFIGURACIÓN DE LA CONSTRUCCIÓN

Usaremos plugins que se centrarán en cuatro fases del ciclo de vida del proyecto: compilación, empaquetado, verificación y despliegue. Aunque pasaremos por todas, éstas son las fases que nos afectarán principalmente a la hora de generar el artefacto.

maven-compiler-plugins

El compilador será el primero. Simplemente estableceremos para qué versión de Java queremos compilar el código fuente del proyecto. Esto no un requisito necesario pero sí importante para poder evitar incompatibilidades dentro del proyecto.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-compiler-plugin</artifactId>
	<version>3.7.0</version>
	<configuration>
		<source>1.8</source>
		<target>1.8</target>
	</configuration>
</plugin>

 

maven-jar-plugin

El empaquetador tendrá el papel de establecer el formato del código compilado. En nuestro caso emplearemos el tipo JAR, pero estos pueden ser diversos según la necesidad.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-jar-plugin</artifactId>
	<version>3.0.2</version>
	<executions>
		<execution>
			<id>jar</id>
			<goals>
				<goal>test-jar</goal>
			</goals>
		</execution>
	</executions>
</plugin>

 

maven-source-plugin

Dentro del grupo de empaquetadores, tenemos algunos plugins adicionales que usaremos sobre todo para añadir más información al artefacto final. En nuestro ejemplo hemos introducido el máximo de información al artefacto. Por ello, añadimos el código sin compilar para que sea accesible bajo el proyecto que lo usara y el javadoc que serán todas las descripciones de los componentes del artefacto.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-source-plugin</artifactId>
	<version>2.0.4</version>
	<executions>
		<execution>
			<id>attach-sources</id>
			<goals>
				<goal>jar</goal>
			</goals>
		</execution>
	</executions>
</plugin>

 

maven-javadoc-plugin

Será el encargado de establecer la configuración de empaquetado de toda la documentación en una distribución de tipo JAR.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-javadoc-plugin</artifactId>
	<version>3.0.0</version>
	<executions>
		<execution>
			<id>attach-javadocs</id>
			<goals>
				<goal>jar</goal>
			</goals>
		</execution>
	</executions>
</plugin>

 

maven-jarsigner-plugin

Para la parte de seguridad añadimos, como buenas prácticas, un firmado. Así nos aseguramos de que no está modificado por un tercero.

Usando este plugin verificamos que el firmado sea correcto. Simplemente se necesita configurar un contenedor de firmas y la firma que deseemos usar sobre el artefacto.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-jarsigner-plugin</artifactId>
	<version>1.4</version>
	<executions>
		<execution>
			<id>sign</id>
			<goals>
				<goal>sign</goal>
			</goals>
		</execution>
		<execution>
			<id>verify</id>
			<goals>
				<goal>verify</goal>
			</goals>
		</execution>
	</executions>
	<configuration>
		<keystore>src/main/resources/keystore.jks</keystore>
		<alias>myalias</alias>
		<storepass>password</storepass>
		<keypass>password</keypass>
	</configuration>
</plugin>

 

CONFIGURACIÓN DEL ENTORNO

Para finalizar sólo nos queda configurar el entorno. Para ello, emplearemos únicamente el gestor de distribuciones que será el que subirá a un repositorio privado nuestro artefacto.

Eso sí, debemos tener en cuenta que tendremos dos tipos de versiones de artefacto:

  • En desarrollo
  • De distribución

Como Maven autogestiona qué versión subir, la única forma de indicárselo es mediante el tag Version de nuestro proyecto mediante los siguientes formatos:

  • Versión en desarrollo: X.X.X-SNAPSHOT
  • Versión de distribución: X.X.X
<distributionManagement>
	<repository>
		<id>releases</id>
		<name>my-project-releases</name>
		<url>http://url_repo/artifactory/my-project-releases</url>
	</repository>
	<snapshotRepository>
		<id>snapshots</id>
		<name>my-project-snapshots</name>
		<url>http://url_repo/artifactory/my-project-snapshots</url>
	</snapshotRepository>
</distributionManagement>

 

 

CONFIGURAR LAS CREDENCIALES

Como sabemos, todo servicio suele estar vinculado a una cuenta. Por tanto, debemos establecer nuestro usuario y contraseña de acceso al repositorio para poder realizar el despliegue.

Siguiendo un modelo de buenas prácticas, Maven recomienda establecer estas credenciales en un fichero llamado settings.xml, Éste será el encargado de definir valores de configuración para ser usada en las ejecuciones (sin ser específicas) para un proyecto en concreto.

Los dos ámbitos que podemos encontrar son:

  • Maven. Será usado como configuración global su ubicación se encuentra en ${maven.home}/conf/settings.xml
  • Usuario. Será usado con la configuración establecida por el usuario su ubicación se encuentra en ${user.home}/.m2/settings.xml

Si es la primera vez que configuramos nuestro fichero como usuario, debemos crearlo e introducir las credenciales de la siguiente manera:

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
	                    https://maven.apache.org/xsd/settings-1.0.0.xsd">
	<servers>
		<server>
			<id>releases</id>
			<username>admin</username>
			<password>password</password>
		</server>
		<server>
			<id>snapshots</id>
			<username>admin</username>
			<password>password</password>
		</server>
	</servers>
</settings>

Debemos tener muy en cuenta el ID que usemos ya que será el que asocie Maven automáticamente con los repositorios definidos anteriormente.

 

 

DESPLEGAR EL ARTEFACTO

Finalmente, teniendo todas las configuraciones establecidas, sólo nos resta desplegar el proyecto. Por tanto, procederemos a abrir un terminal y navegar hasta el directorio del proyecto de nuestro artefacto.

Una vez situados en él, simplemente convocamos el paso de despliegue de nuestro ciclo de vida para efectuar la construcción completa y finalmente la subida al repositorio de nuestro artefacto.

Usaremos la siguiente línea de comando:

$ mvn deploy

 

 

USAR EL ARTEFACTO

Una vez hayamos configurado correctamente el artefacto, podemos usarlo en proyectos. Para ello, debemos configurar el POM de nuestro nuevo proyecto añadiendo la dependencia de nuestro artefacto de la siguiente forma:

<dependency>
	<groupId>testing</groupId>
	<artifactId>my-project-deploy</artifactId>
	<version>1.0.0</version>
</dependency>

 

Esto nos permitirá un uso total de nuestro artefacto siempre y cuando nuestro repositorio sea público. En el caso contrario, debemos definir la ubicación de nuestros repositorios en nuestro proyecto para que entienda de dónde procede.

<repositories>
      <repository>
            <url>http://url_repo/artifactory/my-project-releases<</url>
            <releases>
                  <enabled>true</enabled>
            </releases>
            <snapshots>
                  <enabled>false</enabled>
            </snapshots>
      </repository>
	<repository>
	      <url>http://url_repo/artifactory/my-project-snapshots</url>
            <releases>
                  <enabled>false</enabled>
            </releases>
            <snapshots>
                  <enabled>true</enabled>
            </snapshots>
      </repository>
</repositories>

 

Hemos realizado un proyecto Maven con todas estas configuraciones de despliegue, para que puedas verlo en acción y utilizarlo como dependencia con tu proyecto si quieres. Podrás encontrarlo en nuestro repositorio de Github.