shell - que - ¿Cómo descargar el último artefacto del repositorio de Artifactory?

artifactory vs nexus

Question

Necesito el último artefacto (por ejemplo, una instantánea) de un repositorio en Artifactory . Este artefacto debe copiarse a un servidor (Linux) a través de un script.

¿Cuáles son mis opciones? Algo como Wget / SCP ? ¿Y cómo consigo el camino del artefacto?

He encontrado algunas soluciones que requieren Artifactory Pro. Pero solo tengo Artifactory, no Artifactory Pro.

¿Es posible descargar desde Artifactory sin la interfaz de usuario y no tener la versión Pro? ¿Cuál es la experiencia?

Estoy en OpenSUSE 12.1 (x86_64) si eso importa.

Answer 1

Usando herramientas shell / unix

1. curl ''http://$artiserver/artifactory/api/storage/$repokey/$path/$version/?lastModified''

El comando anterior responde con un JSON con dos elementos: "uri" y "lastModified"

2. Al obtener el enlace en el uri, aparece otro JSON que tiene el "downloadUri" del artefacto.

3. Busque el enlace en "downloadUri" y tendrá el último artefacto.

Usando el plugin Jenkins Artifactory

(Requiere Pro) para resolver y descargar el último artefacto, si el complemento Jenkins Artifactory se usó para publicar en otro trabajo:

1. Seleccione Integración de Artefactos Genéricos
2. Utilice los artefactos resueltos como ${repokey}:**/${component}*.jar;status=${STATUS}@${PUBLISH_BUILDJOB}#LATEST=>${targetDir}

Answer 2

Artifactory tiene un buen REST-API extenso y casi todo lo que se puede hacer en la interfaz de usuario (quizás incluso más) también se puede hacer usando solicitudes HTTP simples.

La característica que mencionas: recuperar el último artefacto, de hecho requiere la edición Pro; pero también se puede lograr con un poco de trabajo de su lado y unos pocos scripts básicos.

Opción 1 - Búsqueda:

Realice una búsqueda GAVC en un conjunto de ID de grupo y coordenadas de ID de artefacto para recuperar todas las versiones existentes de ese conjunto; luego puede usar cualquier algoritmo de comparación de cadenas de versión para determinar la última versión.

Opción 2 - la manera Maven:

Artifactory genera un metadato XML estándar que será consumido por Maven, porque Maven se enfrenta con el mismo problema: determinar la última versión; Los metadatos enumeran todas las versiones disponibles de un artefacto y se generan para cada carpeta de nivel de artefacto; con una simple solicitud GET y algunos análisis de XML, puede descubrir la última versión.

Answer 3

Con las versiones recientes de artifactory, puedes consultar esto a través de la api.

jfrog.com/confluence/display/RTF/…

Si tienes un artefacto maven con 2 instantáneas.

nombre => ''com.acme.derp''
versión => 0.1.0
nombre de repo => ''foo''
snapshot 1 => derp-0.1.0-20161121.183847-3.jar
snapshot 2 => derp-0.1.0-20161122.00000-0.jar

Entonces los caminos llenos serían

https://artifactory.example.com/artifactory/foo/com/acme/derp/0.1.0-SNAPSHOT/derp-0.1.0-20161121.183847-3.jar

y

https://artifactory.example.com/artifactory/foo/com/acme/derp/0.1.0-SNAPSHOT/derp-0.1.0-20161122.00000-0.jar

Obtendrías lo último como:

curl https://artifactory.example.com/artifactory/foo/com/acme/derp/0.1.0-SNAPSHOT/derp-0.1.0-SNAPSHOT.jar

Answer 4

Esto puede ser nuevo:

https://artifactory.example.com/artifactory/repo/com/example/foo/1.0.[RELEASE]/foo-1.0.[RELEASE].tgz

Para cargar el módulo foo desde example.com. Mantenga las partes de [RELEASE] textualmente. Esto se menciona en los documentos, pero no queda suficientemente claro que realmente puede poner [LIBERAR] en la URL (a diferencia de un patrón de sustitución para el desarrollador).

Answer 5

La función de Artifactory es proporcionar archivos para Maven (así como otras herramientas de compilación como Ivy, Gradle o sbt). Puedes usar Maven junto con el maven-dependency-plugin para copiar los artefactos. Aquí hay un esquema pom para empezar ...

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>A group id</groupId>
<artifactId>An artifact id</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>pom</packaging>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.3</version>
<executions>
<execution>
<id>copy</id>
<phase>package</phase>
<goals>
<goal>copy</goal>
</goals>
<configuration>
<artifactItems>
<artifactItem>
<groupId>The group id of your artifact</groupId>
<artifactId>The artifact id</artifactId>
<version>The snapshot version</version>
<type>Whatever the type is, for example, JAR</type>
<outputDirectory>Where you want the file to go</outputDirectory>
</artifactItem>
</artifactItems>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

Solo ejecuta mvn install para hacer la copia.

Answer 6

Puede usar el wget --user=USER --password=PASSWORD .. , pero antes de hacer eso, debe permitir que el artefacto obligue a la autenticación, lo que puede hacerse desactivando la casilla " Ocultar existencia de recursos no autorizados " en Pestaña Seguridad / General en panel de administración de artefactos De lo contrario, artifactory envía una página 404 y wget no puede autenticarse en artifactory.

Answer 7

Puede utilizar el " Último artículo modificado " de la API REST. De los documentos, retoma algo como esto:

GET /api/storage/libs-release-local/org/acme?lastModified
{
"uri": "http://localhost:8081/artifactory/api/storage/libs-release-local/org/acme/foo/1.0-SNAPSHOT/foo-1.0-SNAPSHOT.pom",
"lastModified": ISO8601
}

Ejemplo:

# Figure out the URL of the last item modified in a given folder/repo combination
url=$(curl /
-H ''X-JFrog-Art-Api: XXXXXXXXXXXXXXXXXXXX'' /
''http://<artifactory-base-url>/api/storage/<repo>/<folder>?lastModified'' | jq -r ''.uri'')
# Figure out the name of the downloaded file
downloaded_filename=$(echo "${url}" | sed -e ''s|[^/]*/||g'')
# Download the file
curl -L -O "${url}"

Answer 8

También puede usar Artifactory Query Language para obtener el último artefacto.

El siguiente script de shell es solo un ejemplo. Utiliza ''items.find ()'' (que está disponible en la versión no Pro), por ejemplo, items.find({ "repo": {"$eq":"my-repo"}, "name": {"$match" : "my-file*"}}) que busca archivos que tengan un nombre de repositorio igual a" my-repo "y que coincidan con todos los archivos que comiencen con" my-file ". Luego usa el analizador JSON de shell ./jq para extraer el último archivo ordenándolo por el campo de fecha ''actualizado''. Luego usa wget para descargar el artefacto.

#!/bin/bash
# Artifactory settings
host="127.0.0.1"
username="downloader"
password="my-artifactory-token"
# Use Artifactory Query Language to get the latest scraper script (https://www.jfrog.com/confluence/display/RTF/Artifactory+Query+Language)
resultAsJson=$(curl -u$username:"$password" -X POST http://$host/artifactory/api/search/aql -H "content-type: text/plain" -d ''items.find({ "repo": {"$eq":"my-repo"}, "name": {"$match" : "my-file*"}})'')
# Use ./jq to pars JSON
latestFile=$(echo ${resultAsJson} | jq -r ''.results | sort_by(.updated) [-1].name''))
# Download the latest scraper script
wget -N -P ./libs/ --user $username --password $password http://$host/artifactory/my-repo/$latestFile

Answer 9

Utilizo Nexus y este código funciona para mí: puede recuperar tanto el lanzamiento como el último snaphsot , según el tipo de repositorio:

server="http://example.com/nexus/content/repositories"
repo="snapshots"
name="com.exmple.server"
artifact="com/example/$name"
path=$server/$repo/$artifact
mvnMetadata=$(curl -s "$path/maven-metadata.xml")
echo "Metadata: $mvnMetadata"
jar=""
version=$( echo "$mvnMetadata" | xpath -e "//versioning/release/text()" 2> /dev/null)
if [[ $version = *[!/ ]* ]]; then
jar=$name-$version.jar
else
version=$(echo "$mvnMetadata" | xpath -e "//versioning/versions/version[last()]/text()")
snapshotMetadata=$(curl -s "$path/$version/maven-metadata.xml")
timestamp=$(echo "$snapshotMetadata" | xpath -e "//snapshot/timestamp/text()")
buildNumber=$(echo "$snapshotMetadata" | xpath -e "//snapshot/buildNumber/text()")
snapshotVersion=$(echo "$version" | sed ''s//(-SNAPSHOT/)*$//g'')
jar=$name-$snapshotVersion-$timestamp-$buildNumber.jar
fi
jarUrl=$path/$version/$jar
echo $jarUrl
mkdir -p /opt/server/
wget -O /opt/server/server.jar -q -N $jarUrl

Answer 10

Algo así como el siguiente script de bash recuperará la última instantánea de com.company:artifact del repositorio de snapshot :

# Artifactory location
server=http://artifactory.company.com/artifactory
repo=snapshot
# Maven artifact location
name=artifact
artifact=com/company/$name
path=$server/$repo/$artifact
version=$(curl -s $path/maven-metadata.xml | grep latest | sed "s/.*<latest>/([^<]*/)<//latest>.*//1/")
build=$(curl -s $path/$version/maven-metadata.xml | grep ''<value>'' | head -1 | sed "s/.*<value>/([^<]*/)<//value>.*//1/")
jar=$name-$build.jar
url=$path/$version/$jar
# Download
echo $url
wget -q -N $url

Se siente un poco sucio, sí, pero hace el trabajo.