Comment obtenir une liste des plugins Jenkins installés avec le nom et la paire de versions

160

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

J'ai recherché le document de l'API Jenkins Remote Access, mais il n'a pas été trouvé. Dois-je utiliser la CLI de Jenkins? Y a-t-il un document ou un exemple?

user1284795
la source

Réponses:

161

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

Capture d'écran de la console de script

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 imprimera la liste des résultats comme ceci (découpé):

Capture d'écran de la sortie du script

Cette solution est similaire à l' une des réponses ci-dessus en ce qu'elle utilise Groovy, mais ici, nous utilisons la console de script à la place. 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 sortméthode :

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

Ajustez la fermeture à votre guise (par exemple, ici, elle est triée par le shortName, dans l'exemple, elle est triée par DisplayName)

Behe
la source
2
De toutes les réponses, c'est la plus utile pour déposer un rapport de bogue du plugin; cela peut être fait à l'aide de l'interface Web standard et donne le résultat dans un format qui peut être facilement collé dans le champ "Environnement".
Aaron D. Marasco
8
Excellente réponse pour créer rapidement un plugins.txt pour le docker Jenkins!
Erik Englund
1
Il peut être utile d'ajouter un tri pour que la liste des plugins soit cohérente: Jenkins.instance.pluginManager.plugins.sort({it.getDisplayName()}).each{ plugin -> println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}") }
wheleph
1
C'est la réponse que nous avons choisie localement au lieu de ma suggestion XPath ci-dessus, enveloppée d'une requête curl et d'un élagage des plugins générés à partir de sources, nous utilisons cette approche pour générer le plugins.txt pour notre image docker comme mentionné par @ErikEnglund ci-dessus echo 'script=Jenkins.instance.pluginManager.plugins.each{ plugin -> println ("${plugin.getShortName()}:${plugin.getVersion()}") } null' \ | no_proxy=localhost curl --netrc --silent --data-binary @- -X POST "http://localhost:8080/jenkins/scriptText" | sort > plugins.txt
dbailey le
8
Le tri ne fonctionne pas, c'est une carte non modifiable de nos jours. Utilisation:jenkins.model.Jenkins.instance.getPluginManager().getPlugins().stream().sorted().each { println "${it.getShortName()} | ${it.getVersion()} | ${it.getDisplayName()}" }
Ed Randall
96

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


Vous pouvez utiliser l'API en combinaison avec des arguments de profondeur, 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 pour identifier le 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 plus d'un nœud dans le cadre du résultat, à la fois en ce qu'il fait correspondre plusieurs champs avec XPath et plusieurs nœuds de plug-in.

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

http://<jenkins>/pluginManager/api/xml?depth=1
dbailey
la source
Salut, Savez-vous comment obtenir la liste des plugins qui sont réellement utilisés par les jobs Jenkins et le système Jenkins plutôt que la liste complète des plugins installés? Merci
user1164061
3
A bien fonctionné pour moi sur Mac OS X. Je voulais convertir la sortie en une liste de texte brut, j'ai donc utilisé des expressions régulières Perl pour supprimer les balises:curl 'http://192.168.197.133:8080/pluginManager/api/xml?depth=1&xpath=/*/*/shortName|/*/*/version&wrapper=plugins' | perl -pe 's/.*?<shortName>([\w-]+).*?<version>([^<]+)()(<\/\w+>)+/\1 \2\n/g'
G. Lombard
8
Alternative au format JSON:curl -s -k "http://jenkins/pluginManager/api/json?depth=1" | jq '.plugins[]|{shortName, version,longName}' -c
MarkHu
1
Je pense que cela nécessite des privilèges d'administration, mais je ne suis pas sûr.
mkobit le
2
Confirmé que cela nécessite des privilèges d'administrateur conformément à l'avis de sécurité du 11/05/2016 .
mkobit
29

Jenkins 1,588 (2 e de Novembre 2014) et 1.647 (4 e de Février 2016)

  • Jenkins> Gérer Jenkins

    entrez la description de l'image ici

  • Informations système

    entrez la description de l'image ici

  • Plugins

    entrez la description de l'image ici

ROMANIA_engineer
la source
1
C'est très simple et je peux obtenir la liste du serveur DEV et PRD, les coller dans Excel et comparer leurs versions côte à côte.
Jirong Hu le
24

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

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

wmli
la source
Cela ne listera pas l'état du plugin.
akhan
1
Et la list-pluginscommande CLI n'exige pas que l'utilisateur ait l' autorisation Overall / RunScripts comme le fait la groovycommande.
José Andias
Cela ne semble pas fonctionner avec un jeton API si l'utilisateur / le jeton n'est pas «global / administrateur».
cgseller
21

Utilisez Jenkins CLI comme ceci:

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

=dans l'appel signifie «lire à 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 de l'API Java Jenkins .

malenkiy_scot
la source
@ user1284795, cela vous a-t-il été utile?
malenkiy_scot
1
Salut, savez-vous comment obtenir les plugins utilisés par le système Jenkins et le travail Jenkins au lieu d'installer tous les plugins? J'aimerais que cela m'aide à désinstaller tous les plugins inutilisés. Toute aide est appréciée. Merci!
user1164061
Cela devrait être la réponse acceptée. @ user1164061, je ne pense pas qu'il y ait de différence entre les plugins visibles par un travail et par le serveur. Il existe une isActive()api que vous pouvez utiliser dans le script groovy de cette réponse pour obtenir l'état du plugin. Voir javadoc.jenkins-ci.org/hudson/PluginWrapper.html#isActive () .
akhan
20

Si vous travaillez dans un environnement docker et que vous souhaitez afficher la liste des plugins au format plugins.txt afin de la transmettre à install_scripts.sh, utilisez ces scripts dans la http://{jenkins}/scriptconsole:

  1. Cette version est utile pour obtenir une version de package spécifique
Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:${plugin.getVersion()}")
}
  1. Si vous ne voulez que le plugin avec la dernière version, vous pouvez l'utiliser (merci @KymikoLoco pour le conseil)
Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:latest")
}
Alessandro Lucarini
la source
1
Si vous souhaitez obtenir les dernières versions de tous les plugins, vous pouvez étendre cela pour obtenir uniquement le nom court et ajouter :latestà la fin:println ("${plugin.getShortName()}:latest")
KymikoLoco
17

Les réponses ici étaient quelque peu incomplètes. Et j'ai dû compiler des informations provenant d'autres sources pour acquérir la liste des plugins.

1. Obtenez la 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 ce qui suit sous plugins.groovy.

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

3. Appelez l'API Jenkins pour les résultats du plugin

Appelez le serveur Jenkins ( localhost:8080ici) avec votre nom d'utilisateur et votre mot de passe de connexion tout en faisant référence au 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
noqcks
la source
Les commandes ci-dessus doivent s'exécuter sur votre poste de travail et non sur un travail Jenkins
user3740244
La commande semble entraîner « ERREUR: anonyme manque l'autorisation d' ensemble / Lire » dans les dernières versions .. en passant à la place du auth avant travaillé pour moi java jar-jenkins cli.jar -s localhost: 8080 -auth « admin: < password> "groovy = <plugins.groovy
prasanna
12

La réponse de Behe avec les plugins de tri ne fonctionnait pas sur ma machine Jenkins. J'ai reçu l'erreur java.lang.UnsupportedOperationExceptionen essayant de trier une collection immuable ie 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' http://<jenkins-url>/scriptURL pour exécuter le code.

Alesso
la source
1
J'ai rencontré cela également en utilisant une version de Jenkins différente de celle du premier système sur lequel je l'ai testé. Pour la v2.81, la réponse principale a fonctionné, mais pour LTS v2.83.x et toutes les versions plus récentes, elle a donné l'erreur que vous avez mentionnée alors que votre code fonctionnait toujours.
dragon788
1
Une chose que je viens de remarquer est que vous triez en fonction du displayNamemoment où vous imprimez le shortName, c'était très déroutant car certains plugins ne sont pas les mêmes par ordre alphabétique pour les deux, et il en résulte une liste qui n'apparaît pas triée. Changer it.displayNamepour it.shortNamerésout ce bien.
dragon788
8

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

http://<jenkinsurl>/systemInfo
Andy G
la source
/systeminfone fonctionne pas (HTTP 404) sur Jenkins 1,594
G. Lombard
7
Essayez - http://localhost:8080/systemInfocertains serveurs sont sensibles à la casse. Notez également que l'utilisateur actuellement connecté doit disposer de l'autorisation générale / d'administration.
MarkHu
8

Avec curlet 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 un plugins.txtfichier Jenkins spécial qui vous permet de pré-installer des dépendances (par exemple dans une image docker):

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

Andrzej Rehmann
la source
5

Depuis la page d'accueil de Jenkins:

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

Ou

  1. Accédez directement à l'URL Jenkins: {Votre URL de base Jenkins} / pluginManager / installed
James Lawruk
la source
1
La page "plugins installés" ne reflète pas nécessairement l'état réel du plugin. Par exemple, vous pouvez réactiver un plugin, et voir le plugin vérifié, alors que le plugin est toujours désactivé jusqu'à Jenkins-Restart. Par conséquent, les seules solutions à 100% sont http: // <jenkinsurl> / systeminfo et les réponses à la requête API, à mon humble avis.
t0r0X
4

Partager une autre option trouvée ici avec les 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/ /:/'
Vishnu
la source
comme ci-dessus, mais sans les versions, et triés. curl -sSL "http://127.0.0.1:8080/pluginManager/api/xml?depth=1&xpath=/*/*/shortName|/*/*/version&wrapper=plugins" | perl -pe 's/.*?<shortName>([\w-]+).*?<version>([^<]+)()(<\/\w+>)+/\1 \n/g' | sort
ffghfgh
3

Je voulais une solution qui pourrait fonctionner sur master sans aucune exigence d'authentification et je ne l'ai pas vue ici. J'ai créé un script bash rapide qui extraira toutes les versions du répertoire des 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
Kevin Brotcke
la source
grep Plugin-Version */META-INF/MANIFEST.MF | sed -e 's!/META-INF/MANIFEST.MF:Plugin-Version: !:!g' > ../plugins2.txt
james dupont le
2

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)
Tidhar Klein Orbach
la source
2

Je pense que ce ne sont pas des réponses suffisantes ... beaucoup impliquent quelques étapes supplémentaires sous le capot. Voici comment je l'ai fait.

sudo apt-get install jq

... car la sortie JSON doit être utilisé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
hhony
la source
1

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 des 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).

Wojciech Sciesinski
la source
1
# 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}")
    }
Brian
la source
0

Il y a un tableau répertoriant tous les plugins installés et s'ils sont activés ou non sur http: // jenkins / systemInfo

tsuna
la source
0

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`
Huluvu424242
la source
0

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

REMARQUE: remplacez les sections qui indiquent USERNAME et APIKEY par un UserName et une APIKey valides pour cet utilisateur correspondant. La clé API pour un utilisateur est disponible via l' option Gérer les utilisateursSélectionner un utilisateurClé API .

Vous devrez peut-être prolonger la mise en veille si votre installation Jenkins prend plus de temps à démarrer.

L'initiation yum update -ymettra également à niveau la version si vous avez également installé Jenkins en utilisant 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
##############
gdd1984
la source
0

Il existe de nombreuses façons de récupérer ces informations, mais j'écris de 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. OU depuis la console de script jenkins

Nous devons créer un script groovy pour analyser les informations que nous recevons de l'API jenkins. Cela affichera chaque plugin avec sa version. Enregistrez ce qui suit sous plugins.groovy.

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

user128364
la source