Publicando artefatos Java com Maven em um repositório Nexus

À medida que um projeto de software cresce, o número de dependências aumenta, surgindo a necessidade do gerenciá-las delas de uma forma que seja escalável. Diferentes formas de gerenciamento existem e foram criadas com base nas múltiplas tecnologias e naturezas que os projetos podem ter.

Para algumas linguagens, o código fonte precisa ser compilado antes para que possa ser executado pela máquina. Esse processo cria arquivos que, geralmente, estão atrelados a uma versão. Por conta disso, possuir múltiplas versões sem um mínimo de gerenciamento pode ser uma situação perigosa.

É aqui que Maven e Nexus entram em ação. Juntos eles ajudam na construção e gerenciamento de dependências Java de uma forma simples e confiável. Nesse artigo, mostraremos como publicar artefatos Java usando ambas tecnologias, mas antes, vamos ver uma breve descrição sobre o que são tais tecnologias.

Maven é uma ferramenta de automação usada, principalmente, para projetos Java, que aborda como o software é construído e suas dependências. Ela utiliza um arquivo XML que descreve o projeto de software a ser construído, suas dependências em relação a outros módulos ou componentes externos, a ordem da construção, diretórios e plug-ins requeridos. Maven baixa dinamicamente bibliotecas Java e plug-ins Maven por meio do acesso a um ou mais repositórios como, por exemplo, Maven 2 Central Repository, e os armazena em um cache local.

Nexus é um gerenciador de repositório que armazena “artefatos”, permitindo o acesso direto e gerenciamento de suas dependências, facilitando a distribuição do seu software. Em se tratando de “artefatos”, queremos dizer bibliotecas externas como, por exemplo, arquivos JAR para bibliotecas Java e pacotes para Node. Dessa forma, podemos ter acesso a diversas bibliotecas externas bem como suas várias versões.

Nesse caso, tanto Maven quanto Nexus foram escolhidos, pois eles já eram utilizados em nossa equipe. Uma alternativa ao uso do Maven para publicação de artefatos poderia ser o Gradle e o motivo para o uso de um Nexus interno é termos uma colaboração centralizada e eficiente entre os desenvolvedores e equipes da empresa, além, também, de envolver questões de compliance e segurança da informação da empresa.

Ação!

Para tornar isso o mais simples possível, nós iremos basicamente utilizar os seguintes comandos maven:

• mvn deploy — Usado na maioria das construções de projeto, ele é chamado quando ocorre a fase de implantação (deploy) do ciclo de vida padrão de um projeto maven.
• mvn deploy:deploy-file — Usado para publicar artefatos, que não foram construídos usando Maven, para qualquer repositório remoto.

Para executar ambos os comandos corretamente, precisaremos realizar antes algumas configurações básicas para habilitar o acesso ao repositório interno, assumindo a necessidade de autenticação (no nosso caso é necessária).

Preparando o terreno

Em primeiro lugar, precisamos criar um arquivo com nome “settings.xml” e colocá-lo dentro de uma pasta chamada “.m2", que representa o repositório local do Maven (em qualquer sistema operacional). Esse arquivo contém o “id”, “username” (usuário) e “password” (senha) necessários para acessar nosso Nexus interno, como mostrado abaixo:

<settings>
  <servers>
    <server>
      <id>my-repo-id</id>
      <username>my-username</username>
      <password>my-password</password>
    </server>
  </servers>
</settings>

Essa etapa é essencial para a execução de ambos os comandos!

Executando mvn:deploy

Adicione o seguinte trecho de código dentro do arquivo “pom.xml” do projeto maven que queremos implantar:

<project>
...
 <distributionManagement>
  <repository>
   <id>my-repo-id</id>
   <url>https://my-nexus-repo-address.com</url>
  </repository>
 </distributionManagement>
 <build>
  <pluginManagement>
   <plugins>
    <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-deploy-plugin</artifactId>
     <version>2.8.2</version>
    </plugin>
   </plugins>
  </pluginManagement>
  <plugins>
   <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>sonar-maven-plugin</artifactId>
    <version>3.2</version>
   </plugin>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-deploy-plugin</artifactId>
   </plugin>
  </plugins>
 </build>
</project>

Com essas configurações definidas, podemos rodar nosso “mvn deploy” (nesse caso, eu executei dentro da aba maven do IntelliJ):

mvn deploy -DskipTests -Dmaven.install.skip=true

Ele constrói nosso projeto e sobe para o repositório que definimos no arquivo “pom.xml”. O argumento “-DskipTests” serve para pularmos a etapa de execução de testes da aplicação e “-Dmaven.install.skip=true” ignora a instalação de artefatos localmente. Após executar com sucesso, podemos ver a seguinte mensagem no console da IDE:

Artefato construído e publicado no Nexus com sucesso (debug console do IntelliJ)

Podemos também verificar os arquivos enviados no nosso Nexus:

Artefato no Nexus

Arquivo pom com checksums usado para verificar downloads

Executando mvn deploy:deploy-file

Esse comando nos permite publicar qualquer dependência instalada em nossa máquina para o Nexus, sem precisar ter acesso ao seu código fonte! A única coisa que precisaremos é o arquivo JAR. Isso significa que podemos publicar qualquer artefato, mesmo se ele não tiver sido gerado pelo Maven.

Com “settings.xml” configurado e no lugar certo, antes de executar o comando, temos que prestar atenção no nome do arquivo que queremos subir, visto que ele precisa ser igual ao valor do argumento “-Dfile” que iremos colocar. Agora podemos executá-lo em um terminal Linux:

mvn deploy:deploy-file -Durl=https://my-nexus-repo-address.com -Dfile=my-java-artifact.jar -DgroupId=com.example -DartifactId=my-java-artifact -Dpackaging=jar -Dversion=1.0.0 -DrepositoryId=my-repo-id

Depois de executá-lo com sucesso, deveremos ver a seguinte mensagem no terminal:

Artefato construído e publicado no Nexus com sucesso (terminal do Ubuntu)

Podemos verificar os arquivos que subiram no nosso Nexus:

Artefato no Nexus

Arquivos JAR e pom, ambos com seus checksums

E é isso. Nossos artefatos agora estão hospedados de maneira segura em nosso repositório Nexus!

Conclusão

Ao usar ambos os comandos e o Nexus, nós temos uma forma fácil e rápida de publicar dependências Java em um repositório. Com eles, podemos até “transferir” artefatos de um repositório para outro caso não tenhamos acesso aos seus respectivos projetos maven, o que salva muitas possíveis dores de cabeça (pode confiar, é bem sofrido).

Referências

Apache Maven

“Why Nexus?” for the Non-Programmer

Apache Maven Deploy Plugin — Usage

How does a maven repository work?