Cómo obtener una lista de complementos Jenkins instalados con nombre y par de versiones

160

¿Cómo puedo obtener una lista de complementos instalados de Jenkins?

Busqué el documento de la API de acceso remoto de Jenkins, pero no lo encontré. ¿Debo usar la CLI de Jenkins? ¿Hay un documento o ejemplo?

usuario1284795
fuente

Respuestas:

161

Puede recuperar la información utilizando la consola de script Jenkins, a la que puede acceder visitando http://<jenkins-url>/script. (Dado que ha iniciado sesión y tiene los permisos necesarios).

Captura de pantalla de la consola de script

Ingrese el siguiente script Groovy para iterar sobre los complementos instalados e imprima la información relevante:

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

Imprimirá la lista de resultados de esta manera (recortada):

Captura de pantalla SS de la salida del script

Esta solución es similar a una de las respuestas anteriores en que usa Groovy, pero aquí estamos usando la consola de script. La consola de script es extremadamente útil cuando se usa Jenkins.

Actualizar

Si prefiere una lista ordenada, puede llamar a este sortmétodo :

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

Ajuste el cierre a su gusto (por ejemplo, aquí está ordenado por shortName, en el ejemplo está ordenado por DisplayName)

Behe
fuente
2
De todas las respuestas, esta es la más útil para presentar un informe de error del complemento; se puede hacer usando la interfaz de usuario web estándar y da el resultado en un formato que se puede pegar fácilmente en el campo "Entorno".
Aaron D. Marasco
8
¡Excelente respuesta para crear rápidamente un plugins.txt para Docker Jenkins!
Erik Englund
1
Puede ser útil agregar ordenamiento para que la lista de complementos sea coherente: Jenkins.instance.pluginManager.plugins.sort({it.getDisplayName()}).each{ plugin -> println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}") }
wheleph
1
Esta es la respuesta a la que hemos cambiado localmente en lugar de mi sugerencia de XPath anterior, envuelta con una solicitud de rizo y una poda de complementos construidos a partir de fuentes, utilizamos este enfoque para generar plugins.txt para nuestra imagen acoplable como se menciona anteriormente en @ErikEnglund 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
8
El tipo no funciona, es un mapa inmodificable en estos días. Uso:jenkins.model.Jenkins.instance.getPluginManager().getPlugins().stream().sorted().each { println "${it.getShortName()} | ${it.getVersion()} | ${it.getDisplayName()}" }
Ed Randall
96

En estos días uso el mismo enfoque que la respuesta descrita por @Behe a continuación en lugar de https://stackoverflow.com/a/35292719/1597808


Puede usar la API en combinación con profundidad, XPath y argumentos de contenedor.

Lo siguiente consultará la API del pluginManager para enumerar todos los complementos instalados, pero solo para devolver sus atributos shortName y version. Por supuesto, puede recuperar campos adicionales agregando '|' hasta el final del parámetro XPath y especificando el patrón para identificar el nodo.

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

El argumento de envoltura es obligatorio en este caso, ya que está devolviendo más de un nodo como parte del resultado, ya que coincide con múltiples campos con XPath y múltiples nodos de complementos.

Probablemente sea útil usar la siguiente URL en un navegador para ver qué información en los complementos está disponible y luego decidir qué desea limitar usando XPath:

http://<jenkins>/pluginManager/api/xml?depth=1
dbailey
fuente
Hola, ¿Sabes cómo obtener la lista de complementos que realmente utilizan los trabajos de Jenkins y el sistema de Jenkins en lugar de la lista completa de complementos instalados? Gracias
user1164061
3
Me funcionó bien en Mac OS X. Quería convertir la salida a una lista de texto sin formato, así que usé algunas expresiones regulares de Perl para quitar las etiquetas: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
Alternativa en formato JSON:curl -s -k "http://jenkins/pluginManager/api/json?depth=1" | jq '.plugins[]|{shortName, version,longName}' -c
MarkHu
1
Creo que esto requiere privilegios de administración, pero no estoy seguro.
mkobit
2
Confirmó que esto requiere privilegios de administrador según el aviso de seguridad 2016-05-11 .
mkobit
29

Jenkins 1,588 (2 nd de noviembre de 2014) y 1.647 (4 º de febrero de 2016)

  • Jenkins> Administrar Jenkins

    ingrese la descripción de la imagen aquí

  • Información del sistema

    ingrese la descripción de la imagen aquí

  • Complementos

    ingrese la descripción de la imagen aquí

RUMANIA_ingeniero
fuente
1
Esto es muy simple, y puedo obtener la lista del servidor DEV y PRD, pegarlos en Excel y comparar sus versiones una al lado de la otra.
Jirong Hu
24

La CLI de Jenkins admite la lista de todos los complementos instalados:

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

wmli
fuente
Esto no mostrará el estado del complemento.
akhan
1
Y el list-pluginscomando CLI no requiere que el usuario tenga el permiso General / RunScripts como lo groovyhace el comando.
José Andias
Esto no parece funcionar con un token API si el usuario / token no es "General / Administrador".
cgseller
21

Utilice Jenkins CLI como este:

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

=en la llamada significa 'leer desde la entrada estándar' . pluginEnumerator.groovy contiene el siguiente código Groovy:

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 desea jugar con el código, aquí está la documentación de Jenkins Java API .

malenkiy_scot
fuente
@ user1284795, ¿fue útil?
malenkiy_scot
1
Hola, ¿sabes cómo obtener los complementos utilizados por el sistema Jenkins y el trabajo de Jenkins en lugar de instalar todos los complementos? Me gustaría que esto me ayudara a desinstalar todos los complementos no utilizados. Cualquier ayuda es apreciada. ¡Gracias!
user1164061
Esta debería ser la respuesta aceptada. @ user1164061, no creo que haya ninguna diferencia entre los complementos visibles para un trabajo y el servidor. Hay una isActive()API que puede usar en el script maravilloso en esta respuesta para obtener el estado del complemento. Ver javadoc.jenkins-ci.org/hudson/PluginWrapper.html#isActive () .
akhan
20

Si está trabajando en un entorno docker y desea generar la lista de complementos en un formato plugins.txt para pasar eso a install_scripts.sh, use estos scripts en la http://{jenkins}/scriptconsola:

  1. Esta versión es útil para obtener una versión específica del paquete
Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:${plugin.getVersion()}")
}
  1. Si solo desea el complemento con la última versión, puede usarlo (gracias @KymikoLoco por el consejo)
Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:latest")
}
Alessandro Lucarini
fuente
1
Si desea obtener las últimas versiones de todos los complementos, puede ampliar esto para obtener solo el nombre corto y agregar :latestal final:println ("${plugin.getShortName()}:latest")
KymikoLoco
17

Las respuestas aquí fueron algo incompletas. Y tuve que recopilar información de otras fuentes para adquirir realmente la lista de complementos.

1. Obtenga la CLI de Jenkins

La CLI de Jenkins nos permitirá interactuar con nuestro servidor Jenkins desde la línea de comandos. Podemos obtenerlo con una simple llamada curl.

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

2. Cree un script Groovy para analizar (gracias a malenkiy_scot)

Guarde lo siguiente como plugins.groovy.

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

3. Llame a la API de Jenkins para obtener resultados de complementos

Llame al servidor Jenkins ( localhost:8080aquí) con su nombre de usuario y contraseña de inicio de sesión mientras hace referencia al script Groovy:

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

La salida a plugins.txt se ve así:

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
fuente
Los comandos anteriores deben ejecutarse en su estación de trabajo y no en un trabajo de Jenkins
user3740244
El comando parece dar como resultado "ERROR: a anónimo le falta el permiso General / Leer" en las últimas versiones ... en lugar de pasar la autenticación antes de que funcionara para mí java -jar jenkins-cli.jar -s localhost: 8080 -auth "admin: < contraseña> "groovy = <plugins.groovy
prasanna
12

La respuesta de Behe con los complementos de clasificación no funcionó en mi máquina Jenkins. Recibí el error java.lang.UnsupportedOperationExceptiondebido a intentar ordenar una colección inmutable, es decir Jenkins.instance.pluginManager.plugins. Solución simple para el código:

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

Use la http://<jenkins-url>/scriptURL para ejecutar el código.

Alesso
fuente
1
Me encontré con esto también usando una versión diferente de Jenkins que el primer sistema en el que lo probé. Para v2.81, la respuesta principal funcionó, pero para LTS v2.83.xy cualquier versión más nueva, dio el error que mencionó mientras su código aún funcionaba.
dragon788
1
Una cosa que acabo de notar es que está ordenando según la displayNameimpresión shortName, esto fue muy confuso ya que algunos complementos no son alfabéticamente iguales para ambos, y da como resultado una lista que no aparece ordenada. Cambiar it.displayNamea it.shortNameresuelve esto muy bien.
dragon788
8

Si es administrador de Jenkins, puede usar la página de información del sistema Jenkins:

http://<jenkinsurl>/systemInfo
Andy G
fuente
/systeminfono funciona (HTTP 404) en Jenkins 1.594
G. Lombard
77
Prueba: http://localhost:8080/systemInfoalgunos servidores distinguen entre mayúsculas y minúsculas. Tenga en cuenta también que requiere que el usuario conectado actualmente tenga permiso General / Administrar.
MarkHu
8

Con curly jq:

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

Este comando proporciona la salida en un formato utilizado por un plugins.txtarchivo especial de Jenkins que le permite preinstalar dependencias (por ejemplo, en una imagen acoplable):

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

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

Andrzej Rehmann
fuente
5

Desde la página de inicio de Jenkins:

  1. Haz clic en Administrar Jenkins .
  2. Haz clic en Administrar complementos .
  3. Haga clic en la pestaña Instalado .

O

  1. Vaya a la URL de Jenkins directamente: {Su URL base de Jenkins} / pluginManager / instalado
James Lawruk
fuente
1
La página de "complementos instalados" no refleja necesariamente el estado real del complemento. Por ejemplo, puede volver a habilitar un complemento y ver el complemento marcado, mientras el complemento aún está deshabilitado hasta Jenkins-Reiniciar. Por lo tanto, las únicas soluciones al 100% son http: // <jenkinsurl> / systeminfo y la consulta API responde, en mi humilde opinión.
t0r0X
4

Compartir otra opción encontrada aquí con credenciales

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
fuente
como arriba, pero sin las versiones, y ordenado. 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

Quería una solución que pudiera ejecutarse en master sin ningún requisito de autenticación y no la vi aquí. Hice un script de bash rápido que extraerá todas las versiones del directorio de complementos.

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
fuente
grep Plugin-Version */META-INF/MANIFEST.MF | sed -e 's!/META-INF/MANIFEST.MF:Plugin-Version: !:!g' > ../plugins2.txt
James Dupont
2

Otra opción para usuarios 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
fuente
2

Creo que estas no son respuestas suficientemente buenas ... muchas implican un par de pasos extra bajo el capó. Así es como lo hice.

sudo apt-get install jq

... porque la salida JSON debe consumirse después de llamar a la 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
fuente
1

También puede interesarle qué actualizaciones están disponibles para los complementos. Para eso, debe fusionar los datos sobre complementos instalados con información sobre actualizaciones disponibles aquí https://updates.jenkins.io/current/update-center.json .

Para analizar el archivo descargado como un JSON, debe leer en línea la segunda línea (que es enorme).

Wojciech Sciesinski
fuente
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
fuente
0

Si Jenkins se ejecuta en un contenedor Jenkins Docker, puede usar esta línea de comando en 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
fuente
0

Para Jenkins versión 2.125, funcionó lo siguiente.

NOTA: Reemplace las secciones que dicen USERNAME y APIKEY con un nombre de usuario válido y APIKey para ese usuario correspondiente. La clave API para un usuario está disponible a través de la opción Administrar usuariosSeleccionar usuarioClave API .

Es posible que tenga que extender la suspensión si su instalación de Jenkins tarda más en comenzar.

La iniciación yum update -ytambién actualizará la versión si instaló Jenkins usando yum también.

#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
fuente
0

Hay muchas maneras de obtener esta información, pero escribo de dos maneras como a continuación:

1. Consigue el cli de jenkins.

La CLI de jenkins nos permitirá interactuar con nuestro servidor jenkins desde la línea de comandos. Podemos obtenerlo con una simple llamada curl.

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

2. Crear un guión maravilloso. O desde la consola de script jenkins

Necesitamos crear un script maravilloso para analizar la información que recibimos de la API de jenkins. Esto generará cada complemento con su versión. Guarde lo siguiente como plugins.groovy.

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

usuario128364
fuente