Integrando Open Build Service com GitLab

Como vimos no texto anterior, o Linux Kamarada está migrando para o GitLab. Se você me acompanha há algum tempo, sabe que o desenvolvimento da distribuição ocorria não apenas no GitHub, mas também no Open Build Service (OBS). Enquanto o Git gerencia o código-fonte, o OBS compila os pacotes e imagens ISO da distribuição. Eu já fiz um texto aqui explicando como integrar o Open Build Service com o GitHub. Com a mudança do GitHub para o GitLab, surge a dúvida: é possível integrar o Open Build Service com o GitLab?

Na verdade, antes de iniciar a migração, eu já havia feito esse teste e a resposta é: sim!

Escrevo esse texto para compartilhar como fazer isso, caso mais alguém tenha essa mesma dúvida. Vou repetir algumas informações do texto sobre OBS e GitHub para que esse fique autocontido. Se você não leu o outro texto, não precisa lê-lo, pode ler apenas esse que vai entender tudo. Se já leu o outro texto, fique à vontade para pular o que te parece familiar.

Conheça o Open Build Service (OBS)

Se você desenvolve software para Linux, deveria conhecer o Open Build Service (OBS). O que o torna uma ferramenta tão interessante? Extraído do seu site (tradução livre minha):

O Open Build Service (OBS) é um sistema genérico para compilar e distribuir pacotes binários a partir de códigos-fonte de forma automática, consistente e reprodutível. Você pode distribuir pacotes, assim como atualizações, add-ons, appliances e distribuições Linux inteiras para uma vasta gama de sistemas operacionais e arquiteturas de hardware.

Na prática, você desenvolvedor pode enviar o código-fonte do seu software para o OBS e obter pacotes prontos para instalar no openSUSE, Fedora, Debian, Ubuntu e outras distribuições, assim como pacotes para i586, x86_64, ARM e outras arquiteturas. Os usuários do software podem baixar esses pacotes diretamente do OBS. Ele também é capaz de fazer sistemas Live: você pode oferecer aos seus usuários a possibilidade de testar seu software em um sistema limpo e controlado sem necessidade de instalação.

O OBS é um software livre, de modo que você pode baixá-lo, instalá-lo em um servidor próprio e usá-lo localmente. Ou (mais facil) você pode usar o servidor de referência, disponível pública e gratuitamente em build.opensuse.org. Esse servidor é usado principalmente para o desenvolvimento da distribuição openSUSE, mas também hospeda vários projetos comunitários. Dentre eles, a distribuição Linux Kamarada.

O OBS oferece um sistema de controle de versões próprio, tal qual o Git, e você pode armazenar e gerenciar seu código-fonte diretamente no OBS. Ou, se você já usa o Git em um serviço como o GitLab, pode configurar o OBS para obter o código-fonte desse serviço, de modo que seu software seja sempre compilado, empacotado e disponibilizado para download logo após um git push. Você verá a seguir como configurar essa integração.

Começando a usar o OBS

Não vou falar sobre os conceitos básicos do OBS aqui, seria assunto para um post inteiro. Para aprender o básico do OBS, consulte as páginas a seguir (em inglês):

• Documentation - Open Build Service
• openSUSE:Build Service Tutorial - openSUSE Wiki

Vou assumir que você já consegue entrar (“fazer login”) com sua conta do openSUSE em build.opensuse.org. Se você ainda não tem uma conta, crie uma clicando no link Sign Up (inscrever-se) no topo da página.

Crie um pacote vazio para o seu software no OBS. Aqui vou usar como exemplo o repositório patterns do Linux Kamarada no GitLab, que no momento possui apenas uma imagem PNG e um arquivo spec.

Se você não sabe o que é um arquivo spec e/ou é novo no empacotamento RPM, leia (em inglês):

• Fedora RPM Guide
• openSUSE:Packaging guidelines - openSUSE Wiki

Também vou assumir que você instalou o osc (o cliente de linha de comando do OBS) no seu computador. Se você usa openSUSE, pode instalar o osc executando:

1
# zypper install osc

Crie uma cópia local (“faça checkout”) do seu projeto pessoal (home project) do OBS:

1
$ osc checkout home:seu_nome_de_usuario

Entre na pasta do pacote:

1
$ cd home:seu_nome_de_usuario/nome_do_pacote

Agora vamos integrar o OBS com o GitLab.

OBS: obtendo o código-fonte do GitLab

Usando o osc, configure o serviço de código-fonte (source service) do OBS para obter o código-fonte do GitLab:

1
$ osc add https://gitlab.com/kamarada/patterns.git

É criado na pasta um arquivo _service. Abra-o e substitua seu conteúdo pelo seguinte:

1
2
3
4
5
6
7
8
9
<services>
    <service name="obs_scm">
        <param name="scm">git</param>
        <param name="url">https://gitlab.com/kamarada/patterns.git</param>
        <param name="revision">15.3-dev</param>
        <param name="extract">pattern-kamarada-gnome.png</param>
        <param name="extract">patterns-kamarada-gnome.spec</param>
    </service>
</services>

Note que estou usando o ramo (branch) 15.3-dev. Se você pretende usar o ramo master para o seu pacote, pode simplesmente omitir o parâmetro revision (revisão).

Comite as alterações (“faça o commit” das alterações):

1
$ osc commit

Comitar para o OBS automaticamente dispara o serviço de código-fonte e o processo de compilação e empacotamento. Se você acessar build.opensuse.org, verá que seu projeto está compilando (building):

Para que o GitLab possa disparar essas mesmas ações, você precisa gerar um token de autorização (authorization token) usando o osc:

1
$ osc token --create --operation runservice home:seu_nome_de_usuario nome_do_pacote

O comando retornará o token e sua identificação (id):

1
2
3
4
5
<status code="ok">
  <summary>Ok</summary>
  <data name="token">UmAsTrInGeNoRmEcOmSeUtOkEn</data>
  <data name="id">4321</data>
</status>

Como teste, você pode disparar manualmente a criação do seu pacote usando esse token:

1
$ osc token --trigger UmAsTrInGeNoRmEcOmSeUtOkEn

Se você acessar build.opensuse.org, verá que seu projeto está compilando.

GitLab: avisando novos commits ao OBS

Queremos atualizar o código-fonte do nosso pacote no OBS toda vez que ele mudar no GitLab. Podemos fazer com que o GitLab dispare automaticamente essa atualização configurando um webhook do GitLab. Para fazer isso, execute os passos a seguir.

Entre (sign in) no GitLab e vá até seu repositório (no meu caso, https://gitlab.com/kamarada/patterns). Aponte para Settings (configurações) e clique em Webhooks:

Forneça os seguintes parâmetros:

• URL: https://build.opensuse.org/trigger/runservice?project=home:seu_nome_de_usuario&package=nome_do_pacote
• Secret token (token secreto): UmAsTrInGeNoRmEcOmSeUtOkEn
• Em Trigger, marque Push events (na verdade, já vem marcado por padrão) e informe o nome do branch 15.3-dev

No final, em SSL verification, marque Enable SSL verification (na verdade, já vem marcado por padrão). Para terminar, clique no botão verde Add webhook (adicionar webhook):

De volta à página anterior, você pode ver o webhook adicionado:

Você pode testar o webhook clicando em Test e depois em Push events:

Se você acessar build.opensuse.org, verá que seu projeto está compilando.

A partir de agora, cada git push para o GitLab irá disparar automaticamente uma reconstrução do pacote no OBS. Seu nome de usuário aparecerá no histórico do código-fonte do OBS, que pode ser verificado com o comando osc log.

Divirta-se muito! (Have a lot of fun!)

Referências

• How to integrate external SCM sources - OBS User Guide
• Authorization - OBS User Guide
• Using Source Services - OBS User Guide