web-dev-qa-db-fra.com

Comment télécharger le dernier artefact du référentiel Artifactory?

J'ai besoin du dernier artefact (par exemple, une capture instantanée) d'un référentiel dans Artifactory . Cet artefact doit être copié sur un serveur (Linux) via un script. 

Quelles sont mes options? Quelque chose comme Wget / SCP ? Et comment puis-je obtenir le chemin de l'artefact?

J'ai trouvé des solutions nécessitant Artifactory Pro. Mais j'ai juste Artifactory, pas Artifactory Pro.

Est-il possible de télécharger à partir d'Artifactory sans l'interface utilisateur et sans la version Pro? Quelle est l'expérience?

Je suis sur OpenSUSE 12.1 (x86_64) si cela compte.

shellartifactorycontinuous-deployment
52
user1338413

Artifactory a une bonne REST-API étendue et presque tout ce qui peut être fait dans l'interface utilisateur (peut-être même plus) peut également être fait en utilisant de simples requêtes HTTP.

La fonctionnalité que vous mentionnez - récupérer le dernier artefact, nécessite en effet l'édition Pro; mais cela peut également être réalisé avec un peu de travail de votre côté et quelques scripts de base.

Option 1 - Recherche: 

Effectuez une recherche GAVC sur un ensemble d'ID de groupe et de coordonnées d'ID d'artefact afin de récupérer toutes les versions existantes de cet ensemble; alors vous pouvez utiliser n'importe quel algorithme de comparaison de chaîne de version pour déterminer la dernière version.

Option 2 - à la manière de Maven: 

Artifactory génère une métadonnées XML standard devant être utilisée par Maven, car Maven est confronté au même problème: déterminer la dernière version; Les métadonnées répertorient toutes les versions disponibles d'un artefact et sont générées pour chaque dossier de niveau d'artefact. avec une simple requête GET et une analyse XML, vous pouvez découvrir la dernière version.

29
noamt

Quelque chose comme le script bash suivant récupérera le dernier instantané com.company:artifact du dépôt 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

C'est un peu sale, oui, mais le travail est fait.

59
btiernay

Utilisation des outils Shell/Unix

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

La commande ci-dessus répond par un JSON avec deux éléments - "uri" et "lastModified"

  1. La récupération du lien dans l'URI renvoie un autre JSON qui contient le "downloadUri" de l'artefact.

  2. Récupérez le lien dans "downloadUri" et vous aurez le dernier artefact.

Utiliser le plugin Jenkins Artifactory

(Requiert Pro) pour résoudre et télécharger le dernier artefact, si le plug-in Jenkins Artifactory a été utilisé pour publier sur artefact dans un autre travail:

  1. Sélectionnez l'intégration générique Artifactory
  2. Utiliser les artefacts résolus comme ${repokey}:**/${component}*.jar;status=${STATUS}@${PUBLISH_BUILDJOB}#LATEST=>${targetDir}
11
Sateesh Potturu

Vous pouvez utiliser " Elément modifié en dernier " de l'API REST. À partir de la documentation, il renvoie quelque chose comme ceci:

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
}

Exemple:

# 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}"
4
djhaskin987

Le rôle d’Artifactory est de fournir des fichiers pour Maven (ainsi que d’autres outils de compilation tels que Ivy, Gradle ou sbt). Vous pouvez simplement utiliser Maven avec le maven-dependency-plugin pour copier les artefacts. Voici un aperçu de pom pour commencer ...

<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>

Il suffit de lancer mvn install pour faire la copie.

3
Robert Longson

Vous pouvez également utiliser Artifactory Query Language pour obtenir le dernier artefact.

Le script shell suivant n’est qu’un exemple. Il utilise 'items.find ()' (disponible dans la version non-Pro), par exemple. items.find({ "repo": {"$eq":"my-repo"}, "name": {"$match" : "my-file*"}}) qui recherche les fichiers dont le nom de référentiel est égal à "my-repo" et correspond à tous les fichiers commençant par "my-file". Ensuite, il utilise l’analyseur Shell JSON ./jq pour extraire le fichier le plus récent en effectuant un tri dans le champ de date 'updated'. Enfin, il utilise wget pour télécharger l'artefact.

#!/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
3
Kris

Vous pouvez utiliser la commande wget --user=USER --password=PASSWORD .., mais avant de pouvoir le faire, vous devez autoriser un artificiel à forcer l'authentification, ce qui peut être fait en cochant décochant la case "Masquer l'existence de ressources non autorisées" dans Sécurité/Général onglet dans panneau d'administration artificielle . Sinon, artifactory envoie une page 404 et wget ne peut pas s'authentifier auprès de artifactory.

3
ruhsuzbaykus

Avec les versions récentes de artifactory, vous pouvez l'interroger via l'API. 

https://www.jfrog.com/confluence/display/RTF/Artifactory+REST+API#ArtifactoryRESTAPI-RetrieveLatestArtifact

Si vous avez un artefact maven avec 2 instantanés

nom => 'com.acme.derp'
version => 0.1.0
repo name => 'foo'
instantané 1 => derp-0.1.0-20161121.183847-3.jar
instantané 2 => derp-0.1.0-20161122.00000-0.jar 

Alors les chemins complets seraient

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

et

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

Vous iriez chercher le dernier comme ceci:

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

Cela peut être nouveau:

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

Pour charger le module foo de example.com. Conservez les parties [RELEASE] in extenso. Cela est mentionné dans la documentation, mais il n'est pas précisé clairement que vous pouvez réellement insérer [RELEASE] dans l'URL (par opposition à un modèle de substitution pour le développeur).

1
Jason

Si vous souhaitez télécharger le dernier fichier jar entre 2 dépôts, vous pouvez utiliser cette solution. En fait, je l'utilise dans mon pipeline Jenkins, cela fonctionne parfaitement. Supposons que vous avez un plugins-release-local et un plugins-snapshot-local et que vous souhaitez télécharger le dernier fichier jar entre ceux-ci. Votre script shell devrait ressembler à ceci

NOTE: J'utilise jfrog cli et il est configuré avec mon serveur Artifactory.

Cas d'utilisation: script shell

# your repo, you can change it then or pass an argument to the script
# repo = $1 this get the first arg passed to the script
repo=plugins-snapshot-local
# change this by your artifact path, or pass an argument $2
artifact=kshuttle/ifrs16
path=$repo/$artifact
echo $path
~/jfrog rt download --flat $path/maven-metadata.xml version/
version=$(cat version/maven-metadata.xml | grep latest | sed "s/.*<latest>\([^<]*\)<\/latest>.*/\1/")
echo "VERSION $version"
~/jfrog rt download --flat $path/$version/maven-metadata.xml build/
build=$(cat  build/maven-metadata.xml | grep '<value>' | head -1 | sed "s/.*<value>\([^<]*\)<\/value>.*/\1/")
echo "BUILD $build"
# change this by your app name, or pass an argument $3
name=ifrs16
jar=$name-$build.jar
url=$path/$version/$jar

# Download
echo $url
~/jfrog rt download --flat $url

Cas d'utilisation: Pipeline Jenkins

def getLatestArtifact(repo, pkg, appName, configDir){
    sh """
        ~/jfrog rt download --flat $repo/$pkg/maven-metadata.xml $configDir/version/
        version=\$(cat $configDir/version/maven-metadata.xml | grep latest | sed "s/.*<latest>\\([^<]*\\)<\\/latest>.*/\\1/")
        echo "VERSION \$version"
        ~/jfrog rt download --flat $repo/$pkg/\$version/maven-metadata.xml $configDir/build/
        build=\$(cat  $configDir/build/maven-metadata.xml | grep '<value>' | head -1 | sed "s/.*<value>\\([^<]*\\)<\\/value>.*/\\1/")
        echo "BUILD \$build"
        jar=$appName-\$build.jar
        url=$repo/$pkg/\$version/\$jar

        # Download
        echo \$url
        ~/jfrog rt download --flat \$url
    """
}

def clearDir(dir){
    sh """
        rm -rf $dir/*
    """

}

node('mynode'){
    stage('mysstage'){
        def repos =  ["plugins-snapshot-local","plugins-release-local"]

        for (String repo in repos) {
            getLatestArtifact(repo,"kshuttle/ifrs16","ifrs16","myConfigDir/")
        }
        //optional
        clearDir("myConfigDir/")
    }
}

Cela aide beaucoup lorsque vous souhaitez obtenir le dernier package entre un ou plusieurs dépôts. J'espère que ça vous aidera aussi! Pour plus d’informations sur les pipelines scriptés par Jenkins, visitez le site Documents Jenkins .

0
Rafik

Pour moi, le moyen le plus simple était de lire les dernières versions du projet en combinant curl, grep, sort et tail.

Mon format: service- (version: 1.9.23) - (numéro de version) 156.tar.gz

versionToDownload=$(curl -u$user:$password 'https://$artifactory/artifactory/$project/' | grep -o 'service-[^"]*.tar.gz' | sort | tail -1)
0
Onko