Como posso fazer o Jenkins CI com o Git disparar nos toques para dominar?

Estou tentando configurar o Jenkins-ci para um projeto usando o GitHub. Eu já configurei o Jenkins com os plugins apropriados. Quero que o Jenkins execute scripts de construção apenas sempre que alguém no projeto pressionar para dominar. Até agora, consegui configurá-lo para que uma compilação seja acionada a qualquer momento que alguém for para qualquer lugar, mas isso é muito amplo. Eu fiz isso com ganchos de serviço pós-recebimento no Git.

Eu li o wiki do Jenkins e alguns tutoriais, mas esse detalhe em particular está faltando ... talvez seja algo relacionado à pesquisa? Ou o trabalho deve ser feito no lado do Git, para que o Git só ative Jenkins quando masterfor alterado?

Como já observado por gezzed em seu comentário, enquanto isso, há uma boa solução (descrita em Polling deve morrer: desencadear Jenkins constrói a partir de um gancho Git ):

• Defina o gatilho de construção da tarefa Jenkins como Poll SCM , mas não especifique uma programação.

• Crie um gatilho de pós-recebimento do GitHub para notificar o URL

  http://yourserver/jenkins/git/notifyCommit?url=<URL of the Git repository>?token=<get token from git to build remotely>
  

• Isso acionará todas as compilações que pesquisam o repositório Git especificado.

• No entanto, a pesquisa realmente verifica se alguma coisa foi enviada para a ramificação usada.

Funciona perfeitamente.

A partir da versão 0.5, o plug-in GitHub para Jenkins pode disparar uma compilação quando uma alteração é enviada ao GitHub .

Em vez de disparar construções remotamente, altere a configuração do projeto Jenkins para acionar construções pesquisando.

Jenkins pode pesquisar com base em um interno fixo ou em um URL. O último é o que você deseja pular compilações se não houver alterações para esse ramo. Os detalhes exatos estão na documentação . Basicamente, você só precisa marcar a opção "Poll SCM", deixar a seção de agendamento em branco e definir um URL remoto para pressionar JENKINS_URL / job / name / polling.

Uma dica se você tiver um ambiente Jenkins protegido é diferente /build, a /pollingURL requer autenticação. As instruções aqui têm detalhes. Por exemplo, eu tenho um gancho GitHub Post-Receive indo para username:apiToken@JENKIS_URL/job/name/polling.

Para o GitLab , siga estas etapas:

1. Vá para as configurações do seu projeto → Ganchos da Web

2. Digite o URL "Build Now" do seu projeto Jenkins como um URL de evento push:

   http://server.com/jenkins/job/project_name/build?delay=0sec por exemplo

3. Clique Add Web Hooke depoistest hook

Então, sempre que você se comprometer com o repositório, o gancho da web é acionado e uma compilação é criada. Certifique-se de definir o espaço de trabalho do Jenkins para delete workspace before each buildobter uma nova cópia do novo código.

Não relacionado ao Git, mas abaixo ajudarei com a configuração do trabalho Jenkins em detalhes com o Mercurial. Pode ajudar outras pessoas com um problema semelhante.

1. Instale o plug-in de acionador de URL
2. Vá para a página de configuração do trabalho e selecione a Poll SCMopção. Defina o valor como* * * * *
3. Marque a opção: [URLTrigger] - Poll with a URL. Agora você pode selecionar algumas opções, como alteração de data de modificação, conteúdo do URL etc.
4. Nas opções, selecione Alterar o conteúdo do URL, selecione a primeira opção - Monitor change of content
5. Salve as alterações.

Agora, acione algumas alterações no repositório Mercurial fazendo alguns check-ins de teste.

Veja que o trabalho Jenkins agora é executado detectando as alterações do SCM. Quando a compilação for executada devido a alterações do Mercurial, você verá um texto Started by an SCM change. Senão, o usuário que o iniciou manualmente.

Espero que isso ajude: Como acionar uma compilação Jenkins no Git commit

É apenas uma questão de usar curl para acionar um trabalho Jenkins usando os ganchos Git fornecidos pelo Git.

O comando curl http://localhost:8080/job/someJob/build?delay=0secpode executar um trabalho Jenkins, onde someJobé o nome do trabalho Jenkins.

Procure a pasta "hooks" na sua pasta .git oculta. Renomeie o arquivo "post-commit.sample" para "post-commit". Abra-o com o bloco de notas, remova a linha ": Nothing" e cole o comando acima.

É isso aí. Sempre que você faz uma confirmação, o Git aciona os comandos pós-confirmação definidos no arquivo.

Integração contínua com o Jenkins, depois que o código é enviado para o repositório a partir do comando Git / GUI:

1. Crie um trabalho no Jenkins com apenas o nome do trabalho e selecione o tipo de estilo livre do projeto. Clique em OK. A próxima página não adiciona nada - basta clicar emSave .
2. Vá para o seu repositório Git local, onde você tem o código-fonte e navegue até a .git/hookspasta.

3. A hookspasta contém os poucos arquivos. Verifique o "pós-confirmação". Se não estiver presente, crie um arquivo, "pós-confirmação" sem uma extensão de arquivo:

   C:\work\test\\.git\hooks\post-commit
   

4. Edite o arquivo "pós-confirmação" com o comando abaixo. Verifique se ele está presente na pasta de ganchos do código-fonte local.

   curl -u userName:apiToken -X POST http://localhost:8080/jenkins/job/jobName/build?token=apiToken
   

   Exemplo:

   curl -u admin:f1c55b3a07bb2b69b9dd549e96898384 -X POST http://localhost:8080/jenkins/job/Gitcommittest/build?token=f1c55b3a07bb2b69b9dd549e96898384
   

   5)

   userName: Nome de usuário de Jenkins

   jobName: Nome da tarefa da construção

   apiToken: Para obter seu token de API, acesse a página de usuário do Jenkins (canto superior direito da interface). Está disponível no menu "Configurar", à esquerda da página: "Mostrar token da API"

5. Faça alterações no seu código-fonte e confirme o código no repositório.

6. Seu trabalho http://localhost:8080/jenkins/job/Gitcommittest/deve estar construindo.

Você precisa especificar o ramo. Por padrão, ele ouve qualquer coisa. Veja a postagem do blog Hudson: plugins Git e Maven .

O plug-in de gatilho Webhook genérico pode ser configurado com filtros para isso.

Quando configurado com

• Uma variável nomeada refe expressão $.ref.
• Um filtro com texto $refe expressão de filtro como ^refs/heads/master$.

Em seguida, esse trabalho será acionado a cada push para master . Nenhuma pesquisa.

Você provavelmente deseja mais valores do webhook para realmente executar a compilação. Basta adicionar mais variáveis, com JSONPath, para escolher o que você precisa.

Existem alguns casos de uso aqui: https://github.com/jenkinsci/generic-webhook-trigger-plugin/tree/master/src/test/resources/org/jenkinsci/plugins/gwt/bdd

Na minha organização atual, não fazemos isso no master, mas no desenvolvimento e no release / branches (estamos usando o Git Flow), para gerar builds de snapshots.

Como estamos usando um pipeline de várias ramificações, fazemos isso no arquivo Jenkins com a sintaxe when {} ...

stage {
    when { 
        expression { 
            branch 'develop'
        }
    }
}

Isso está detalhado nesta postagem do blog: https://jenkins.io/blog/2017/01/19/converting-conditional-to-pipeline/#longer-pipeline

As respostas acima estão corretas, mas estou abordando quem é novato aqui por sua simplicidade

especialmente para definir o gatilho de compilação para o pipeline:

Considere que você tem duas ramificações do Github: 1.master, 2.dev e Jenkinsfile (onde o script de pipeline está gravado) e outros arquivos estão disponíveis em cada ramificação

Configurar novo projeto Pipeline (para ramificação dev)

## 1.Integração do código com o git-plugin e a abordagem baseada em cron Pré-requisito O plug-in git deve ser instalado e configurado com seu nome e email

1. Seção Geral. Marque a caixa de seleção - 'Este projeto está parametrizado' e adicione Nome-SBRANCH Valor padrão-'refs / remotes / origin / dev '
2. Seção de gatilhos de compilação "Marque a caixa de seleção - 'Poll SCM' e programe conforme a necessidade de verificar confirmações, por exemplo, '* / 1 * * * *' para verificar a cada minuto
3. Seção de definição de pipeline.Selecione - Script de pipeline em SCM—> selecione git—> URL addRepository—> adicione credenciais git—> escolha avançado—> adicione Origem de nome, RefSpec- '+ refs / heads / dev: refs / remotes / origin / dev '(dev é ramificação do github) -> Ramos a serem construídos - $ {SBRANCH} (nome do parâmetro da ref 1º ponto) -> caminho do script—> Jenkinsfile -> Desmarcar Lightweightcheckout
4. Aplicar—> salvar

## 2.Integração de código: abordagem do github-plugin e webhook Pré-requisito O plug-in do Github deve ser instalado e o servidor do Github deve ser configurado, a conexão deve ser testada se não considerar a seguinte configuração

Configurar o plug-in do Github com uma conta no Jenkins

Seção GitHub Adicione servidor Github se não estiver presente URL da API: https://api.github.com Credenciais: adicione texto secreto (clique no botão Adicionar: selecione o tipo de texto secreto) com o valor Token de acesso pessoal (gere-o nas suas contas do Github—> configurações -> configuração do desenvolvedor—> token de acesso pessoal—> adicionar token—> verificar escopos—> copiar o token) Testar Conexão—> Verifique se ele está conectado à sua conta do Github ou não. Marque a caixa de seleção na subseção Gerenciar ganchos. Antes, apenas selecione credencial anterior para 'segredo compartilhado'

Adicione webhook se não for adicionado ao seu repositório

1. Vá para a configuração do Repositório do Github -> adicione webhook—> adicione URL
   http: // IP_ Público: Jenkins_PORT / github-webhook /
2. Ou se você não possui o Public_IP, use o ngrok . Instale, autentique, obtenha o IP público pelo comando ./ngrok http 80 (use seu jenkins_port) e adicione webhook -> adicione URL http: // Ngrok_IP / github-webhook /
3. Teste-o entregando carga útil da página webhook e verifique se você recebe 200 status ou não.

Se você possui o plug-in de solicitações Github Pull, configure-o também com o URL publicado do Jenkins.

1. Seção geral. Marque a caixa de seleção - 'Projeto Github' adicionar URL do projeto - (link do github que termina com '.git /')
2. Seção Geral. Marque a caixa de seleção - 'Este projeto está parametrizado' e adicione Nome-SBRANCH Valor padrão-'refs / remotes / origin / dev '
3. Caixa de seleção Build triggers.section.Check - 'Gatilho de gancho do GitHub para pesquisa de GITScm'
4. Seção de definição de pipeline: Selecione - Script de pipeline no SCM—> selecione git—> URL do repositório add -> adicione credenciais de git—> escolha avançado -> adicione Nome de origem, RefSpec- '+ refs / heads / dev: refs / remotes / origem / dev '(dev é ramificação do github) -> Ramos a serem construídos - $ {SBRANCH} (nome do parâmetro da ref 1.st ponto) -> caminho do script—> Jenkinsfile—> desmarcar Verificação leve
5. Aplicar—> salvar

Use o plug-in do pull request builder: https://wiki.jenkins-ci.org/display/JENKINS/GitHub+pull+request+builder+plugin

É realmente simples. Você pode configurar os webhooks do GitHub para acionar compilações.

Minha solução para um servidor git local: vá para o diretório de gancho do servidor git local, ignore o update.sample existente e crie um novo arquivo literalmente chamado de "update", como:

gituser@me:~/project.git/hooks$ pwd
/home/gituser/project.git/hooks
gituser@me:~/project.git/hooks$ cat update
#!/bin/sh
echo "XXX from  update file"
curl -u admin:11f778f9f2c4d1e237d60f479974e3dae9 -X POST http://localhost:8080/job/job4_pullsrc_buildcontainer/build?token=11f778f9f2c4d1e237d60f479974e3dae9

exit 0
gituser@me:~/project.git/hooks$ 

A instrução echo será exibida sob o resultado do git push, o token pode ser obtido na configuração do seu trabalho jenkins, procure-o. Se o arquivo "update" não for chamado, tente outros arquivos com o mesmo nome sem a extensão "sample".

É tudo o que você precisa