Como obter uma lista dos plugins Jenkins instalados com par de nome e versão


160

Como posso obter uma lista dos plugins Jenkins instalados?

Pesquisei o documento da API de acesso remoto Jenkins, mas ele não foi encontrado. Devo usar a CLI do Jenkins? Existe um documento ou exemplo?

Respostas:


161

Você pode recuperar as informações usando o Jenkins Script Console, que pode ser acessado visitando http://<jenkins-url>/script. (Como você está logado e possui as permissões necessárias).

Captura de tela do console de scripts

Digite o seguinte script Groovy para percorrer os plugins instalados e imprimir as informações relevantes:

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

Irá imprimir a lista de resultados como esta (cortada):

SScreenshot da saída do script

Essas soluções são semelhantes a uma das respostas acima , pois ele usa o Groovy, mas aqui estamos usando o console de scripts. O console de script é extremamente útil ao usar o Jenkins.

Atualizar

Se você preferir uma lista classificada, pode chamar 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 o Closure ao seu gosto (por exemplo, aqui é classificado pelo shortName, no exemplo, pelo DisplayName)


2
De todas as respostas, essa é a mais útil para arquivar um relatório de bug do plugin; isso pode ser feito usando a interface do usuário da web padrão e fornece o resultado em um formato que pode ser facilmente colado no campo "Ambiente".
Aaron D. Marasco #

8
Ótima resposta para criar rapidamente um plugins.txt para o docker Jenkins!
precisa

1
Pode ser útil adicionar classificação para que a lista de plugins seja consistente: Jenkins.instance.pluginManager.plugins.sort({it.getDisplayName()}).each{ plugin -> println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}") }
wheleph 18/11/16

1
Esta é a resposta para a qual mudamos localmente, em vez da minha sugestão XPath acima, envolvida com uma solicitação de curvatura e algumas podas de plugins criados a partir da fonte, usamos essa abordagem para gerar o plugins.txt para a nossa imagem do docker, conforme mencionado por @ErikEnglund acima 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
A classificação não funciona, é um mapa inalterável atualmente. Use:jenkins.model.Jenkins.instance.getPluginManager().getPlugins().stream().sorted().each { println "${it.getShortName()} | ${it.getVersion()} | ${it.getDisplayName()}" }
Ed Randall

96

Hoje em dia, uso a mesma abordagem da resposta descrita por @Behe abaixo https://stackoverflow.com/a/35292719/1597808


Você pode usar a API em combinação com os argumentos de profundidade, XPath e wrapper.

A seguir, você consultará a API do pluginManager para listar todos os plugins instalados, mas apenas para retornar seus atributos shortName e versão. Obviamente, você pode recuperar campos adicionais adicionando '|' até o final do parâmetro XPath e especificando o padrão para identificar o nó.

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

O argumento do wrapper é necessário nesse caso, porque está retornando mais de um nó como parte do resultado, pois está correspondendo a vários campos com o XPath e vários nós do plug-in.

Provavelmente é útil usar o seguinte URL em um navegador para ver quais informações nos plug-ins estão disponíveis e depois decidir o que você deseja limitar usando o XPath:

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

Olá, Você sabe como obter a lista de plug-ins que são realmente usados ​​pelos trabalhos Jenkins e pelo sistema Jenkins, em vez da lista completa de plug-ins instalados? Graças
user1164061

3
Funcionou bem para mim no Mac OS X. Eu queria converter a saída para uma lista de texto puro, então usei alguns Perl regex para retirar as tags: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 no formato JSON:curl -s -k "http://jenkins/pluginManager/api/json?depth=1" | jq '.plugins[]|{shortName, version,longName}' -c
MarkHu 8/01/16

1
Acredito que isso requer privilégios de administração, mas não tenho certeza.
Mkobit

2
Confirmado que isso requer privilégios de administrador de acordo com o comunicado de segurança de 11/05/2016 .
Mkobit 28/03/19

29

Jenkins 1.588 (2 nd de novembro de 2014) e 1,647 (4 th de fevereiro de 2016)

  • Jenkins> Gerenciar Jenkins

    insira a descrição da imagem aqui

  • Informação do sistema

    insira a descrição da imagem aqui

  • Plugins

    insira a descrição da imagem aqui


1
Isso é muito simples e posso obter a lista dos servidores DEV e PRD, colá-los no Excel e comparar suas versões lado a lado.
Jirong Hu 4/16

24

A CLI do Jenkins suporta a listagem de todos os plugins instalados:

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


Isso não listará o estado do plug-in.
Akhan

1
E o list-pluginscomando da CLI não exige que o usuário tenha a permissão Geral / RunScripts como o groovycomando.
José Andias 12/12

Isso não parece funcionar com um token da API se o usuário / token não for "Geral / Administrador".
cgseller

21

Use a Jenkins CLI assim:

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

=na chamada significa 'ler da entrada padrão' . pluginEnumerator.groovy contém o seguinte 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()}"

Se você gostaria de brincar com o código, aqui está a documentação da API Java do Jenkins .


@ user1284795, foi útil?
malenkiy_scot

1
Olá, você sabe como obter os plugins usados ​​pelo sistema Jenkins e pelo trabalho Jenkins em vez de instalar todos os plugins? Gostaria que isso me ajudasse a desinstalar todos os plugins não utilizados. Qualquer ajuda é apreciada. Obrigado!
User1164061

Essa deve ser a resposta aceita. @ user1164061, acho que não há diferença entre plugins visíveis para um trabalho e para o servidor. Há uma isActive()API que você pode usar no script groovy nesta resposta para obter o estado do plug-in. Consulte javadoc.jenkins-ci.org/hudson/PluginWrapper.html#isActive () .
Akhan

20

Se você estiver trabalhando em um ambiente de docker e quiser gerar a lista de plug-ins no formato plugins.txt para passar isso para o install_scripts.sh, use estes scripts no http://{jenkins}/scriptconsole:

  1. Esta versão é útil para obter versão específica do pacote
Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:${plugin.getVersion()}")
}
  1. Se você deseja apenas o plugin com a versão mais recente, pode usá-lo (obrigado @KymikoLoco pela dica)
Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:latest")
}

1
Se você deseja obter as versões mais recentes de todos os plugins, pode estendê-lo para obter apenas o nome abreviado e adicionar :latestaté o final:println ("${plugin.getShortName()}:latest")
KymikoLoco

17

As respostas aqui eram um tanto incompletas. E eu tive que compilar informações de outras fontes para realmente adquirir a lista de plugins.

1. Obtenha a CLI do Jenkins

A CLI Jenkins nos permitirá interagir com nosso servidor Jenkins a partir da linha de comando. Podemos obtê-lo com uma chamada simples.

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

2. Crie um script Groovy para análise (graças a malenkiy_scot)

Salve o seguinte como plugins.groovy.

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

3. Ligue para a API Jenkins para obter resultados do plug-in

Ligue para o servidor Jenkins ( localhost:8080aqui) com seu nome de usuário e senha de login enquanto faz referência ao script Groovy:

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

A saída para plugins.txt é assim:

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

Os comandos acima deve ser executado em sua estação de trabalho e não em um trabalho Jenkins
user3740244

O comando parece resultar em "ERROR: anonymous está faltando a autorização geral / Ler" em versões mais recentes .. em vez de passar a autenticação antes trabalhou para mim java -jar Jenkins-cli.jar -s localhost: 8080 -auth "admin: < senha> "groovy = <plugins.groovy
prasanna

12

A resposta de Behe com a classificação de plug-ins não funcionou na minha máquina Jenkins. Eu recebi o erro java.lang.UnsupportedOperationExceptiondevido a tentar classificar uma coleção imutável, ou seja Jenkins.instance.pluginManager.plugins. Correção simples para o código:

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

Use o http://<jenkins-url>/scriptURL para executar o código.


1
Encontrei isso também usando uma versão diferente do Jenkins do que o primeiro sistema em que o testei. Para a v2.81, a resposta principal funcionou, mas para o LTS v2.83.x e quaisquer versões mais recentes, ocorreu o erro que você mencionou enquanto seu código ainda funcionava.
precisa saber é o seguinte

1
Uma coisa que notei é que você está classificando com base na displayNameimpressão shortName, isso foi muito confuso, pois alguns plugins não são alfabeticamente os mesmos para ambos, e resulta em uma lista que não aparece classificada. Mudar it.displayNamepara it.shortNameresolve isso muito bem.
dragon788

8

Se você é um administrador Jenkins, pode usar a página de informações do sistema Jenkins:

http://<jenkinsurl>/systemInfo

/systeminfonão funciona (HTTP 404) em Jenkins 1.594
G. Lombard

7
Experimente - http://localhost:8080/systemInfoalguns servidores diferenciam maiúsculas de minúsculas. Observe também que ele requer que o usuário conectado no momento tenha permissão Geral / Administrar.
MarkHu

8

Com curle jq:

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

Este comando fornece a saída em um formato usado pelo plugins.txtarquivo Jenkins especial que permite pré-instalar dependências (por exemplo, em uma imagem do docker):

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

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


5

Na página inicial do Jenkins:

  1. Clique em Gerenciar Jenkins .
  2. Clique em Gerenciar plug-ins .
  3. Clique na guia Instalado .

Ou

  1. Acesse o URL do Jenkins diretamente: {Seu URL base do Jenkins} / pluginManager / installed

1
A página "plugins instalados" não reflete necessariamente o status real do plug-in. Por exemplo, você pode reativar um plug-in e ver o plug-in marcado, enquanto o plug-in ainda está desativado até Jenkins-Restart. Portanto, as únicas soluções 100% são http: // <jenkinsurl> / systeminfo e as respostas da consulta da API, imho.
T0r0X

4

Compartilhando outra opção encontrada aqui com credenciais

JENKINS_HOST=username:password@myhost.com: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/ /:/'

como acima, mas sem as versões e classificadas. 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
precisa saber é o seguinte

3

Eu queria uma solução que pudesse ser executada no master sem nenhum requisito de autenticação e não a vi aqui. Eu criei um script bash rápido que retirará todas as versões do diretório de 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

grep Plugin-Version */META-INF/MANIFEST.MF | sed -e 's!/META-INF/MANIFEST.MF:Plugin-Version: !:!g' > ../plugins2.txt
james dupont

2

Outra opção para usuários do 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)

2

Acho que essas respostas não são boas o suficiente ... muitas envolvem algumas etapas extras ocultas. Aqui está como eu fiz isso.

sudo apt-get install jq

... porque a saída JSON precisa ser consumida depois que você chama a 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

1

Você também pode estar interessado em quais atualizações estão disponíveis para plug-ins. Para isso, é necessário mesclar os dados sobre plug-ins instalados com informações sobre atualizações disponíveis aqui https://updates.jenkins.io/current/update-center.json .

Para analisar o arquivo baixado como um JSON, você deve ler on-line a segunda linha (que é enorme).


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}")
    }


0

Se o Jenkins for executado no contêiner Jenkins Docker, você poderá usar esta linha de comando no 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

Para a versão 2.125 do Jenkins, o seguinte funcionou.

NOTA: Substitua as seções que dizem USERNAME e APIKEY por um UserName e APIKey válidos para o usuário correspondente. A chave da API para um usuário está disponível em Gerenciar usuáriosSelecionar usuárioChave da API .

Pode ser necessário prolongar a suspensão se a instalação do Jenkins demorar mais para iniciar.

A iniciação yum update -ytambém atualizará a versão se você instalou o Jenkins usando o 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

Existem várias maneiras de obter essas informações, mas estou escrevendo de duas maneiras, como abaixo: -

1. Obtenha o jenkins cli.

A CLI Jenkins nos permitirá interagir com nosso servidor Jenkins a partir da linha de comando. Podemos obtê-lo com uma chamada simples.

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

2. Crie um script groovy. OU do console de scripts jenkins

Precisamos criar um script groovy para analisar as informações que recebemos da API jenkins. Isso produzirá cada plug-in com sua versão. Salve o seguinte como plugins.groovy.

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

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.