web-dev-qa-db-fra.com

Comment obtenir une liste des plugins Jenkins installés avec paire nom/version

Comment puis-je obtenir une liste des plugins Jenkins installés? 

J'ai effectué une recherche dans le document API d'accès distant Jenkins, mais celui-ci n'a pas été trouvé. Devrais-je utiliser la CLI de Jenkins? Y a-t-il un document ou un exemple?

jenkinsjenkins-plugins
98
user1284795

Vous pouvez récupérer les informations à l'aide de Jenkins Script Console , accessible en visitant http://<jenkins-url>/script. (Étant donné que vous êtes connecté et que vous disposez des autorisations requises).

Screenshot of the Script Console

Entrez le (script Groovy) suivant pour parcourir les plugins installés et imprimer les informations pertinentes:

Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}")
}

Il va imprimer la liste des résultats comme ceci (coupé):

 SScreenshot of script output

Cette solution est similaire à une des réponses ci-dessus en ce sens qu’elle utilise Groovy, mais ici, nous utilisons plutôt la console de script. La console de script est extrêmement utile lors de l'utilisation de Jenkins.

Mettre à jour

Si vous préférez une liste triée, vous pouvez appeler cette méthode sort :

Jenkins.instance.pluginManager.plugins.sort { it.getDisplayName() }.each{
  plugin -> 
    println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}")
}

Ajustez la fermeture à vos goûts.

100
Behe

Aujourd'hui, j'utilise la même approche que la réponse décrite par @Behe à la place https://stackoverflow.com/a/35292719/1597808

Vous pouvez utiliser l'API en combinaison avec les arguments depth, XPath et wrapper.

Ce qui suit interrogera l'API de pluginManager pour répertorier tous les plugins installés, mais uniquement pour renvoyer leurs attributs ShortName et version. Vous pouvez bien sûr récupérer des champs supplémentaires en ajoutant '|' à la fin du paramètre XPath et en spécifiant le modèle d'identification du nœud.

wget http://<jenkins>/pluginManager/api/xml?depth=1&xpath=/*/*/shortName|/*/*/version&wrapper=plugins

L'argument wrapper est requis dans ce cas, car il renvoie plusieurs nœuds dans le résultat, en ce sens qu'il fait correspondre plusieurs champs aux nœuds XPath et plugin.

Il est probablement utile d'utiliser l'URL suivante dans un navigateur pour voir quelles informations sur les plugins sont disponibles, puis de décider de ce que vous souhaitez limiter à l'aide de XPath:

http://<jenkins>/pluginManager/api/xml?depth=1
90
dbailey

Jenkins 1,588 (2dakota du Nord de novembre 2014) & 1.647 (4th de février 2016)

  • Jenkins> Gérer Jenkins

     enter image description here

  • Informations système

     enter image description here

  • Plugins

     enter image description here

24
ROMANIA_engineer

Utilisez Jenkins CLI comme ceci:

Java -jar jenkins-cli.jar -s http://[jenkins_server] groovy = < pluginEnumerator.groovy

= dans l'appel signifie 'lu à partir de l'entrée standard'. pluginEnumerator.groovy contient le code Groovy suivant:

println "Running plugin enumerator"
println ""
def plugins = jenkins.model.Jenkins.instance.getPluginManager().getPlugins()
plugins.each {println "${it.getShortName()} - ${it.getVersion()}"}
println ""
println "Total number of plugins: ${plugins.size()}"

Si vous souhaitez jouer avec le code, voici la documentation sur l'API Java de Jenkins .

19
malenkiy_scot

Jenkins CLI prend en charge la liste de tous les plugins installés:

Java -jar jenkins-cli.jar -s http://localhost:8080/ list-plugins

17
wmli

Les réponses ici étaient quelque peu incomplètes. Et je devais compiler des informations à partir d'autres sources pour obtenir la liste des plugins.

1. Obtenez le CLI Jenkins

La CLI Jenkins nous permettra d’interagir avec notre serveur Jenkins à partir de la ligne de commande. Nous pouvons l'obtenir avec un simple appel curl.

curl 'localhost:8080/jnlpJars/jenkins-cli.jar' > jenkins-cli.jar

2. Créez un script Groovy pour l'analyse (grâce à malenkiy_scot)

Enregistrez les éléments suivants sous le nom plugins.groovy.

def plugins = jenkins.model.Jenkins.instance.getPluginManager().getPlugins()
plugins.each {println "${it.getShortName()}: ${it.getVersion()}"}

3. Appelez l'API Jenkins pour obtenir les résultats du plug-in.

Appelez le serveur Jenkins (localhost:8080 ici) avec votre nom d’utilisateur et votre mot de passe pour référencer le script Groovy:

Java -jar jenkins-cli.jar -s http://localhost:8080 groovy --username "admin" --password "admin" = < plugins.groovy > plugins.txt

La sortie vers plugins.txt ressemble à ceci:

ace-editor: 1.1
ant: 1.5
antisamy-markup-formatter: 1.5
authentication-tokens: 1.3
blueocean-autofavorite: 1.0.0
blueocean-commons: 1.1.4
blueocean-config: 1.1.4
blueocean-dashboard: 1.1.4
blueocean-display-url: 2.0
blueocean-events: 1.1.4
blueocean-git-pipeline: 1.1.4
blueocean-github-pipeline: 1.1.4
blueocean-i18n: 1.1.4
blueocean-jwt: 1.1.4
blueocean-personalization: 1.1.4
blueocean-pipeline-api-impl: 1.1.4
blueocean-pipeline-editor: 0.2.0
blueocean-pipeline-scm-api: 1.1.4
blueocean-rest-impl: 1.1.4
14
noqcks

La réponse de Behe ​​ avec les plugins de tri ne fonctionne pas sur ma machine Jenkins. J'ai reçu l'erreur Java.lang.UnsupportedOperationException après avoir essayé de trier une collection immuable, à savoir Jenkins.instance.pluginManager.plugins. Solution simple pour le code:

List<String> jenkinsPlugins = new ArrayList<String>(Jenkins.instance.pluginManager.plugins);
jenkinsPlugins.sort { it.displayName }
              .each { plugin ->
                   println ("${plugin.shortName}:${plugin.version}")
              }

Utilisez l'URL http://<jenkins-url>/script pour exécuter le code.

7
Alesso

De la page d'accueil Jenkins:

  1. Cliquez sur Manage Jenkins.
  2. Cliquez sur Gérer les plugins.
  3. Cliquez sur l'onglet Installed.

Ou

  1. Accédez directement à l'URL Jenkins: {Votre URL de base Jenkins}/pluginManager/installed
7
James Lawruk

Si vous êtes un administrateur Jenkins, vous pouvez utiliser la page d'informations système Jenkins:

http://<jenkinsurl>/systemInfo
4
Andy G

Partage d'une autre option trouvée ici avec informations d'identification

JENKINS_Host=username:[email protected]:port
curl -sSL "http://$JENKINS_Host/pluginManager/api/xml?depth=1&xpath=/*/*/shortName|/*/*/version&wrapper=plugins" | Perl -pe 's/.*?<shortName>([\w-]+).*?<version>([^<]+)()(<\/\w+>)+/\1 \2\n/g'|sed 's/ /:/'
3
vishnu

Si vous travaillez dans un environnement de menu fixe et souhaitez exporter la liste des plug-ins au format plugins.txt afin de la transmettre à install_scripts.sh, utilisez ce script dans la console http://{jenkins}/script.

Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:${plugin.getVersion()}")
}
3
Alessandro Lucarini

Je pense que ce ne sont pas assez bonnes réponses ... beaucoup impliquent quelques étapes supplémentaires supplémentaires. Voici comment je l'ai fait.

Sudo apt-get install jq

... car la sortie JSON doit être consommée après l'appel de l'API.

#!/bin/bash
server_addr = 'jenkins'
server_port = '8080'

curl -s -k "http://${server_addr}:${server_port}/pluginManager/api/json?depth=1" \
  | jq '.plugins[]|{shortName, version,longName,url}' -c | sort \
  > plugin-list

echo "dude, here's your list: "
cat plugin-list
2
hhony

Avec curl et jq:

curl -s <jenkins_url>/pluginManager/api/json?depth=1 \
  | jq -r '.plugins[] | "\(.shortName):\(.version)"' \
  | sort

Cette commande donne la sortie dans un format utilisé par le fichier Jenkins plugins.txt spécial qui vous permet de pré-installer des dépendances (par exemple, dans une image de menu fixe):

ace-editor:1.1
ant:1.8
Apache-httpcomponents-client-4-api:4.5.5-3.0

Exemple de plugins.txt: https://github.com/hoto/jenkinsfile-examples/blob/master/source/jenkins/usr/share/jenkins/plugins.txt

2
Andrzej Rehmann

Une autre option pour les utilisateurs de Python:

from jenkinsapi.jenkins import Jenkins

#get the server instance
jenkins_url = 'http://<jenkins-hostname>:<jenkins-port>/jenkins'
server = Jenkins(jenkins_url, username = '<user>', password = '<password>')

#get the installed plugins as list and print the pairs
plugins_dictionary = server.get_plugins().get_plugins_dict()
for key, value in plugins_dictionary.iteritems():
    print "Plugin name: %s, version: %s" %(key, value.version)
1
Tidhar Klein Orbach

Il existe un tableau répertoriant tous les plugins installés et indiquant s'ils sont activés ou non à http: // jenkins/systemInfo

0
tsuna

Vous pouvez également être intéressé par les mises à jour disponibles pour les plugins. Pour cela, vous devez fusionner les données sur les plugins installés avec les informations sur les mises à jour disponibles ici https://updates.jenkins.io/current/update-center.json . 

Pour analyser le fichier téléchargé en tant que JSON, vous devez lire en ligne la deuxième ligne (ce qui est énorme).

0
Wojciech Sciesinski

Pour Jenkins version 2.125, ce qui suit a fonctionné.

REMARQUE: remplacez les sections portant le nom USERNAME et APIKEY par un nom d'utilisateur et une clé API valides pour l'utilisateur correspondant . La clé API d'un utilisateur est disponible via Gestion des utilisateurs → Sélectionner un utilisateur → _ {Clé API} option.

Vous devrez peut-être prolonger votre sommeil si l'installation de Jenkins prend plus de temps à démarrer.

L'initiation yum update -y mettra également à niveau la version si vous avez également installé Jenkins avec yum.

#JENKINS AUTO UPDATE SCRIPT link this script into a cron
##############
!/bin/bash
Sudo yum update -y
sleep 120
UPDATE_LIST=$( Sudo /usr/bin/Java -jar /var/cache/jenkins/war/WEB-INF/jenkins-cli.jar -auth [USERNAME:APIKEY] -s http://localhost:8080/ list-plugins | grep -e ')$' | awk '{ print $1 }' );
if [ ! -z "${UPDATE_LIST}" ]; then
    echo Updating Jenkins Plugins: ${UPDATE_LIST};
    Sudo /usr/bin/Java -jar /var/cache/jenkins/war/WEB-INF/jenkins-cli.jar -auth [USERNAME:APIKEY] -s http://localhost:8080/ install-plugin ${UPDATE_LIST};
    Sudo /usr/bin/Java -jar /var/cache/jenkins/war/WEB-INF/jenkins-cli.jar -auth [USERNAME:APIKEY] -s http://localhost:8080/ safe-restart;
fi
##############
0
gdd1984
# list of plugins in sorted order
# Copy this into your Jenkins script console
    def plugins = jenkins.model.Jenkins.instance.getPluginManager().getPlugins()

    List<String> list = new ArrayList<String>()

    i = 0
    plugins.each {
      ++i
      //println " ${i}  ${it.getShortName()}: ${it.getVersion()}"
      list.add("${it.getShortName()}: ${it.getVersion()}")
    }

    list.sort{it}
    i = 0
    for (String item : list) {
      i++
      println(" ${i} ${item}")
    }
0
Brian

Si Jenkins s'exécute dans un conteneur Jenkins Docker, vous pouvez utiliser cette ligne de commande dans Bash:

Java -jar /var/jenkins_home/war/WEB-INF/jenkins-cli.jar -s http://localhost:8080/ list-plugins --username admin --password `/bin/cat /var/jenkins_home/secrets/initialAdminPassword`
0
FunThomas424242

Je voulais une solution qui puisse fonctionner sur le maître sans aucune exigence en matière d'authentification et je ne l'ai pas vue ici. J'ai fait un script bash rapide qui extraira toutes les versions du répertoire plugins.

if [ -f $JENKINS_HOME/plugin_versions.txt ]; then
  rm $JENKINS_HOME/plugin_versions.txt
fi

for dir in $JENKINS_HOME/plugins/*/; do
  dir=${dir%*/}
  dir=${dir##*/}
  version=$(grep Plugin-Version $JENKINS_HOME/plugins/$dir/META-INF/MANIFEST.MF | awk -F': ' '{print $2}')
  echo $dir $version >> $JENKINS_HOME/plugin_versions.txt
done
0
Kevin Brotcke

Il y a beaucoup de façons de récupérer cette information, mais j'écris deux manières comme ci-dessous: -

1. Obtenez le cli jenkins.

La CLI jenkins nous permettra d’interagir avec notre serveur jenkins à partir de la ligne de commande. Nous pouvons l'obtenir avec un simple appel curl.

curl 'localhost:8080/jnlpJars/jenkins-cli.jar' > jenkins-cli.jar

2. Créez un script groovy. OR à partir de la console de script jenkins

Nous devons créer un script groovy pour analyser les informations que nous recevons de l'API jenkins. Cela produira chaque plugin avec sa version. Enregistrez les éléments suivants sous le nom plugins.groovy.

def plugins = jenkins.model.Jenkins.instance.getPluginManager().getPlugins() plugins.each {println "${it.getShortName()}: ${it.getVersion()}"}

0
user128364