for - ¿Cómo obtener una lista de complementos jenkins instalados con nombre y par de versiones?
jenkins project (15)
¿Cómo puedo obtener una lista de complementos jenkins instalados? Se buscó el documento API de acceso remoto de Jenkins pero no se encontró. ¿Debería usar Jenkins CLI? ¿Hay algún documento o ejemplo?
@Behe la respuesta con los complementos de clasificación no funcionó en mi máquina Jenkins. Recibí el error java.lang.UnsupportedOperationException debido 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}")
}
http://<jenkins-url>/script url para ejecutar el código.
Compartir otra opción que se encuentra here con las 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/ /:/''
Creo que estas respuestas no son lo suficientemente buenas. Muchas implican un par más bajo los pasos del cofre. Así es como lo hice.
sudo apt-get install jq
.. porque la salida json necesita ser consumida 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
Desde la página de inicio de Jenkins:
- Haz clic en Administrar Jenkins .
- Haga clic en Administrar complementos .
- Haga clic en la pestaña Instalado .
O
- Diríjase a la URL de Jenkins directamente: {Su jenkins base Url} / pluginManager / installed
Hay una tabla que enumera todos los complementos instalados y si están habilitados o no en http://jenkins/systemInfo
La CLI de Jenkins admite la lista de todos los complementos instalados:
java -jar jenkins-cli.jar -s http://localhost:8080/ list-plugins
Las respuestas aquí fueron algo incompletas. Y tuve que recopilar información de otras fuentes para realmente adquirir la lista de complementos.
1. obtener la jenkins cli
La CLI de jenkins nos permitirá interactuar con nuestro servidor jenkins desde la línea de comando. Podemos obtenerlo con una simple llamada curl.
curl ''localhost:8080/jnlpJars/jenkins-cli.jar'' > jenkins-cli.jar
2. crea una secuencia de comandos 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. llamar a la API de Jenkins para obtener resultados de complementos
Llame al servidor jenkins (localhost: 8080 aquí) con su nombre de usuario y contraseña de inicio de sesión al hacer referencia a la secuencia de comandos 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
Otra opción para los 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)
Para Jenkins ver 2.125, lo siguiente funcionó.
NOTA: reemplace las secciones que dicen USERNAME y APIKEY con un UserName y APIKey válidos para ese usuario correspondiente. La clave de API para un usuario está disponible a través de la opción ManageUsers >> Select User >> Key Key.
Es posible que tengas que extender el sueño si tus jenkins tardan más en comenzar.
El yum update de iniciación también actualizará la versión si instalaste 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
##############
Puede recuperar la información utilizando la Consola de script de Jenkins a la que puede acceder visitando http://<jenkins-url>/script . (Dado que ha iniciado sesión y tiene los permisos necesarios).
Ingrese el siguiente script de Groovy para iterar sobre los complementos instalados e imprimir 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):
Esta solución es similar a una de las respuestas anteriores en que usa Groovy, pero aquí estamos usando la consola de script en su lugar. La consola de script es extremadamente útil cuando se usa Jenkins.
Actualizar
Si prefiere una lista ordenada, puede llamar a este método de sort :
Jenkins.instance.pluginManager.plugins.sort { it.getDisplayName() }.each{
plugin ->
println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}")
}
Ajuste el cierre a sus gustos.
Puede usar la API en combinación con los argumentos depth, xpath y wrapper
Lo siguiente consultará la API del pluginManager para listar todos los complementos instalados, pero solo para devolver sus atributos shortName y versión. Por supuesto, puede recuperar campos de adición 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
En este caso, se requiere el argumento contenedora porque devuelve más de un nodo como parte del resultado, tanto en que está combinando varios campos con el xpath como con múltiples nodos de complementos.
Probablemente sea útil utilizar la siguiente url en un navegador para ver qué información sobre los complementos está disponible y luego decidir qué quiere limitar con xpath:
http://<jenkins>/pluginManager/api/xml?depth=1
Si jenkins se ejecuta en el 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`
Si usted es el administrador de Jenkins, puede usar la página de información del sistema de Jenkins:
http://<jenkinsurl>/systemInfo
Use la CLI de Jenkins así:
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 de 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 la API Java de Jenkins .
