Linux Kamarada

Como fazer uma distro baseada no openSUSE (bastidores do Linux Kamarada): começando

Como fazer uma distribuição Linux baseada no openSUSE é um tutorial que eu imagino fazer há algum tempo já. Agora que o Linux Kamarada já tem duas versões lançadas (15.1, descontinuada, e 15.2, atual) e uma terceira a caminho (a 15.3) creio que consigo explicar como fazer. Decidi aproveitar a oportunidade, já que comecei a trabalhar na próxima versão, para registrar o processo e compartilhar como faço, pro caso de ser útil para mais alguém.

Não necessariamente seu objetivo precisa ser criar uma distribuição para disponibilizar na Internet. Pode ser que você só queira personalizar o openSUSE (ou — por que não? — o Linux Kamarada) para instalar nos computadores da empresa ou órgão público em que trabalha. Ou talvez você esteja desenvolvendo um software e queira criar uma imagem Live com seu software já instalado, de modo a facilitar o teste por potenciais usuários ou a demonstração em eventos. Um sistema Live é um ambiente controlado, ideal para testes.

Seja qual for seu objetivo, esse post e os seguintes podem te ajudar a alcançá-lo.

O tutorial será formado na verdade por alguns posts. À medida em que eu for avançando no desenvolvimento do Linux Kamarada 15.3, vou compartilhando o que estou fazendo e como.

Pretendo fazer algo prático, então não vou me aprofundar em detalhes sobre as ferramentas — principalmente Git, Kiwi e Open Build Service (OBS) — de modo que esse tutorial não dispensa a consulta a outras fontes. Aliás, muito do que aprendi foi “dando a cara a tapa”: pesquisando, tentando, errando e pedindo ajuda em fóruns, grupos e listas de discussão. Então esse tutorial será mais para mostrar o caminho e atalhar a pesquisa, em vez de ser auto contido. Depois, com o tempo, posso fazer outros tutoriais para preencher as lacunas.

Hoje, veremos como iniciar o desenvolvimento da distribuição: como criar o projeto no Open Build Service e como criar o primeiro pacote. Vou mostrar como dei o pontapé inicial no Linux Kamarada 15.3. Vamos lá!

Ingredientes: do que vamos precisar

Como eu disse na notícia de lançamento do Linux Kamarada 15.2, o desenvolvimento do Linux Kamarada ocorre no GitHub e no OBS. Na verdade, para a versão 15.3, estou migrando do GitHub para o GitLab. Eu prefiro usar o Git para armazenar e gerenciar o código-fonte e o OBS para compilar e empacotar, embora também seja possível fazer tudo isso no OBS. Fique à vontade para usar o GitHub, o GitLab, outro serviço de Git (como o Bitbucket) ou só o OBS.

Se você ainda não conhece o OBS, leia a primeira seção — Conheça o Open Build Service (OBS) — do texto:

Guarde esse texto porque vamos voltar a ele mais tarde.

Se você prefere usar o GitHub, leia esse texto, em vez do anterior:

Vou assumir que você já tem uma conta em um serviço como o GitHub ou o GitLab, que já consegue entrar (“fazer login”) nela e que já tem familiaridade com o Git.

Para hospedar os repositórios do Git do projeto, eu recomendo criar uma organização (no caso do GitHub) ou um grupo (no caso do GitLab), exemplos: github.com/kamarada ou gitlab.com/kamarada. Mas você também pode usar seu perfil pessoal, exemplo: gitlab.com/antoniomedeiros. Pro OBS, isso não faz diferença.

Também vou assumir que você já consegue entrar 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.

Por fim, também vou assumir que você está usando uma das distribuições do openSUSE (Leap ou Tumbleweed) ou uma distribuição baseada nelas (como o Linux Kamarada). Se estamos falando em fazer uma distro baseada no openSUSE, nada me parece mais natural.

Instale o Git e o osc (o cliente de linha de comando do OBS) no seu computador:

1

# zypper in git osc

O padrão do Linux Kamarada

Caso você não saiba o que são padrões no openSUSE, eu expliquei esse conceito no texto:

Aquele texto apresenta o ponto de vista do usuário. Agora veremos o ponto de vista de quem faz a distribuição.

Para definir quais pacotes compõem o Linux Kamarada, eu criei um padrão para ele, tomando como exemplo outros padrões do openSUSE:

Por isso é fácil, como eu disse na notícia de lançamento do Linux Kamarada 15.2, transformar qualquer instalação do openSUSE Leap em uma instalação do Linux Kamarada: basta adicionar o repositório da distribuição e instalar o pacote patterns-kamarada-gnome.

Como criar padrões

Se você quiser ver como padrões são definidos no openSUSE, acesse software.opensuse.org e pesquise por patterns. Vários pacotes cujo nome contém patterns são listados. Todos eles correspondem a padrões. Clique em um pacote.

A página seguinte lista a disponibilidade desse pacote para várias distribuições. Abaixo da distribuição desejada, clique em official release (versão oficial) para ver o código-fonte desse pacote no OBS:

Nessa tela, estamos vendo os arquivos que compõem o código-fonte do pacote patterns-xfce no projeto openSUSE:Leap:15.2 do OBS. Desses arquivos, o principal é o arquivo spec.

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

De forma resumida, é esse arquivo spec que define o pacote RPM. No caso do padrão, esse arquivo diz o nome e a descrição do padrão e suas dependências (pacotes requeridos, recomendados ou sugeridos). Por exemplo, o arquivo spec do padrão do XFCE:

O código-fonte do padrão do Linux Kamarada pode ser visto em:

Os arquivos mais importantes são:

Abrindo o arquivo spec, logo no início temos o nome (Name), a descrição (Summary) e a versão (Version) do padrão (tenho que atualizar esse endereço — Url):

1
2
3
4
5
6
7
8

Name:           patterns-kamarada-gnome
Summary:        Linux Kamarada with GNOME desktop
Url:            https://github.com/openSUSE/patterns
Version:        15.2
Release:        0
Group:          Metapackages
License:        MIT
BuildRoot:      %{_tmppath}/%{name}-%{version}-build

Mais adiante, temos a linha que define o ícone do padrão:

1

Source0:        pattern-kamarada-gnome.png

E ao longo do arquivo temos as dependências do padrão.

O padrão do Linux Kamarada depende de outros padrões:

1
2
3
4

Requires:       pattern() = apparmor
Requires:       pattern() = enhanced_base
Requires:       pattern() = x11_enhanced
Requires:       pattern() = gnome_basis

(essas linhas não estão juntas no arquivo, estão espalhadas, não vou reproduzir o arquivo fielmente aqui pro texto ficar mais fluido)

Achei melhor não criar muitas dependências de outros padrões, pra ter um controle maior sobre os pacotes que são instalados. Em vez disso, eu copiei as dependências que eu queria desses padrões e os mantive comentados, pra ter uma ideia de onde eu as obtive:

1
2
3
4
5
6
7
8
9

#Requires:       pattern() = enhanced_base_opt

Requires:       man-pages
Requires:       man-pages-posix

Requires:       unzip

Requires:       tcpdump
Requires:       telnet

Minha estratégia para os pacotes, de modo geral, é:

  • pacotes que eu considero essenciais são requeridos (Requires) — se você não tem esses pacotes, eu não considero que você tem uma instalação do Linux Kamarada (note que a remoção desses pacotes ocasiona a remoção do padrão); e
  • traduções ou outros pacotes que são úteis, mas não para todos os computadores, são recomendados (Recommends) ou sugeridos (Suggests) — por exemplo, os pacotes ucode-amd e ucode-intel são sugeridos, os dois vem instalados por padrão, mas dependendo do seu processador, você pode perfeitamente remover um ou outro (a remoção desses pacotes não ocasiona a remoção do padrão, eu considero que você continua tendo uma instalação do Linux Kamarada ainda que remova esses pacotes).

Outros exemplos de padrões

Aqui estão exemplos de padrões que consulto para definir o meu e que talvez possam servir de referência para você também:

  • patterns-base: código-fonte para os padrões apparmor, base, console, enhanced_base, minimal_base, x11 e x11_enhanced
  • patterns-gnome: código-fonte para os padrões gnome_x11, gnome_basis, gnome_basic, gnome_games, gnome_imaging, gnome_internet, gnome_utilities e gnome_yast
  • patterns-yast: código-fonte para os padrões yast2_basis e yast2_install_wf

Agora que você já entendeu a ideia básica por trás do padrão, vamos pôr a mão na massa.

Criando o padrão no Git

Note que eu já tenho um repositório no Git para o meu padrão (gitlab.com/kamarada/patterns). Sendo assim, vou usá-lo como ponto de partida. Talvez você precise criar um repositório.

Eu costumo usar um branch para cada versão (15.1, 15.2) e um branch para o desenvolvimento de cada versão (15.1-dev, 15.2-dev). Sendo assim, posso experimentar no branch de desenvolvimento e mesclar com o principal quando estiver pronto.

Vou criar o branch 15.3-dev usando como ponto de partida o 15.2-dev.

Para isso, no repositório local do Git:

1
2

$ git checkout 15.2-dev
$ git checkout -b 15.3-dev

Mudei a versão no arquivo spec

1

Version:        15.3

Fiz o commit:

1

$ git commit -a

E enviei a alteração para o repositório remoto (como estamos criando esse branch, no primeiro push precisamos definir o remote):

1

$ git push --set-upstream origin 15.3-dev

Criando os projetos no OBS

No openSUSE Build Service, acesse o seu projeto pessoal por meio do link Your Home Project na barra lateral do OBS. Mude para a aba Subprojects (subprojetos). Em seguida, clique em Create Subproject (criar subprojeto):

Como nome do subprojeto (Subproject Name) eu defini 15.3 e como título (Title) eu defini Linux Kamarada 15.3:

Depois clique em Accept (aceitar).

Feito isso, agora temos um projeto no OBS para o Linux Kamarada 15.3 em:

Entrei no projeto home:kamarada:15.3 e criei mais um subprojeto, esse chamado dev, resultando no projeto home:kamarada:15.3:dev:

Se você voltar à lista de subprojetos do projeto principal do usuário, verá os dois projetos recém criados:

Configurando os repositórios

Entre no projeto de desenvolvimento (no meu caso, home:kamarada:15.3:dev), mude para a aba Repositories (repositórios) e clique em Add from a Distribution (adicionar de uma distribuição):

Marque o repositório do openSUSE Leap 15.3:

E no final da página também o repositório do Kiwi:

Os repositórios já são adicionados ao projeto assim que você os marca. Não precisa clicar em nenhum botão. Volte para a aba Repositories.

Temos então dois repositórios configurados para esse projeto:

  • o images, que será usado para produzir a imagem ISO; e
  • o openSUSE_Leap_15.3, que será usado para produzir os pacotes RPM.

A menos que você queira compilar sua distribuição para todas as arquiteturas suportadas pelo Kiwi, precisamos fazer uma “poda” nas arquiteturas do repositório images (imagens).

Para isso, no repositório images, clique no ícone de editar:

Deixe marcadas apenas as arquiteturas para as quais você vai compilar sua distribuição (no meu caso, apenas x86_64). Quando terminar, clique em Update (atualizar):

Para cada repositório do nosso projeto no OBS, podemos configurar quais outros repositórios de outros projetos ele considera na hora de obter pacotes.

No caso do openSUSE Leap 15.3, vamos adicionar o repositório de atualização.

Para isso, clique no ícone de adicionar:

Em Project (projeto), informe openSUSE:Leap:15.3:Update:

Em Repositories (repositórios), mantenha standard (padrão) e clique em Accept.

Como o repositório openSUSE:Leap:15.3:Update já considera o repositório openSUSE:Leap:15.3, e o OBS tem a “inteligência” de perceber isso, podemos remover o repositório openSUSE:Leap:15.3, pra deixar nossa configuração mais enxuta:

No caso das imagens do Kiwi, adicione os seguintes repositórios:

  • seu próprio repositório de pacotes (no meu caso, home:kamarada:15.3:dev/openSUSE_Leap_15.3)
  • o repositório com a versão mais recente do Kiwi (Virtualization:Appliances:Builder/openSUSE_Leap_15.3, recomendação da documentação do Kiwi)
  • repositório de atualização do openSUSE Leap 15.3 (openSUSE:Leap:15.3:Update/standard)

No final, deve ficar assim:

Feita essa configuração de repositórios no projeto de desenvolvimento (no meu caso, home:kamarada:15.3:dev), você pode fazer configuração semelhante no projeto principal (home:kamarada:15.3).

Criando o padrão no OBS

No projeto de desenvolvimento (no meu caso, home:kamarada:15.3:dev), mude para a aba Overview (visão geral) e clique em Create Package (criar pacote):

Dê pelo menos um nome (Name) para o pacote (no meu caso, patterns-kamarada-gnome) e clique em Create (criar):

Criado o pacote do padrão no OBS, vamos trazê-lo para o computador para trabalhar nele localmente, de modo análogo ao que fazemos clonando um repositório do Git.

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

1

$ osc checkout home:kamarada:15.3:dev

Entre na pasta do pacote:

1

$ cd home:kamarada:15.3:dev/patterns-kamarada-gnome

Integrando o OBS com o Git

Agora vamos integrar o OBS com o Git, para que o código-fonte do pacote seja obtido do Git e compilado no OBS. Para instruções de como fazer isso, consulte um dos tutoriais a seguir, conforme o provedor de Git que você usa (GitLab ou GitHub):

Primeiro pacote pronto

Ao final, voltando para a visão geral do repositório de desenvolvimento, temos nosso primeiro pacote compilado com sucesso no OBS:

Tem mais alguns pacotes no Linux Kamarada que são compilados por essa dupla OBS + Git. Com o roteiro apresentado aqui, já vou dar o pontapé inicial nesses pacotes também.

Siga o Linux Kamarada nas redes sociais se quiser ser avisado de novos episódios dessa jornada.

Me paga um café?
Se você gostou muito, se foi muito útil pra você, será que vale um café? Se quiser, você pode "me pagar um café" pelo PayPal ou contribuir com o projeto de outras formas.

Comentários

Sobre

O Projeto Linux Kamarada visa divulgar e promover o Linux como um sistema operacional robusto, seguro, versátil e fácil de usar, adequado para o uso diário seja em casa, no trabalho ou no servidor. Os focos do projeto são principalmente distribuição e documentação.

Anúncios

Facebook

Linux Kamarada

Twitter

Autor