Makepkg (Português)
makepkg é um script usado para automatizar a compilação de pacotes. Os requisitos para usar o script são uma plataforma tipo Unix capaz de compilar e um PKGBUILD.
O makepkg é fornecido pelo pacote pacman.
Configuração
Veja makepkg.conf(5) para detalhes sobre as opções de configuração do makepkg.
A configuração do sistema está disponível em , mas alterações específicas para cada usu[ario podem ser feitas em ou . É recomendado revisar a configuração antes de compilar pacotes.
Informação do empacotador
Cada pacote é marcado com metadados identificando, entre outros, também o empacotador. Por padrão, os pacotes compilados pelo usuário são marcados com . Se vários usuários estiverem compilando pacotes em um sistema, ou de outra forma estiverem distribuindo os pacotes para outros usuários, é conveniente fornecer contato real. Isso pode ser feito configurando a variável PACKAGER em makepkg.conf.
Para verificar isso em um pacote instalado:
Para automaticamente produzir pacotes assinados, defina também a variável em makepkg.conf.
Saída de pacote
Por padrão, makepkg cria os tarballs de pacote no diretório atual de trabalho e baixa os dados fonte diretamente para o diretório . Caminhos personalizados podem ser configurados, por exemplo, para manter todos os pacotes compilados em e todos os fontes em .
Configure as seguintes variáveis do makepkg.conf, se necessário:
- – diretório para armazenar pacotes resultantes
SRCDEST– diretório para armazenar dados fonte (links simbólicos serão colocados em se ele aponta para outro lugar)- – diretório para armazenar os pacotes fontes (compilado com )
PKGDEST pode ser limpado com, p. ex., paccache -c ~/build/pacotes/ como descrito em pacman (Português)#Limpando o cache de pacotes.Verificação de assinatura
Se um arquivo de assinatura na forma de .sig ou .asc é parte do vetor fonte do PKGBUILD, o makepkg tenta automaticamente verificá-la. No caso do chaveiro do usuário não contém a chave pública necessária para verificação de assinatura, o makepkg vai abortar a instalação com uma mensagem de que a chave PGP não pôde ser verificada.
Se uma chave pública necessária para um pacote está faltando, o PKGBUILD muito provavelmente vai conter uma entrada validpgpkeys com os IDs de chaves necessárias. Importe-a manualmente, ou localize-a em um servidor de chaves e importe-a de lá. Para temporariamente desabilitar verificação de assinatura, execute o makepkg com a opção .
Uso
Antes de continuar, instale o grupo . Os pacotes que pertencem a este grupo não são exigidos na lista de dependência de compilação (makedepends) nos arquivos PKGBUILD.
Para compilar um pacote, deve-se primeiro criar um PKGBUILD, ou um script de compilação, como descrito em Criando pacotes. Scripts existentes estão disponíveis na árvore do Arch Build System (ABS) ou do AUR. Uma vez em posse de um , altere o diretório no qual está salvo e execute o seguinte comando para compilar o pacote:
$ makepkg
Se estiverem faltando dependências necessárias, o makepkg emitirá um aviso antes de falhar. Para compilar o pacote e instalar as dependências necessárias, adicione a opção :
$ makepkg --syncdeps
Adicionar as opções /--rmdeps faz com que o makepkg remova as dependências de compilação logo em seguida, já que não são mais necessárias. Se estiver compilando pacotes constantemente, considere usar Pacman/Dicas e truques#Removendo pacotes não usados (órfãos) de vez em quando.
Uma vez que todas as dependências estejam satisfeitas e os pacotes compilados com sucesso, um arquivo de pacote (pkgname-pkgver.pkg.tar.zst) será criado no diretório. Para instalar, use / (o mesmo que ):
# pacman --install
Para limpar arquivos e diretórios restantes, tais como arquivos extraídos para $, adicione a opção /--clean. Isso é útil para várias compilações do mesmo pacote ou ao atualizar a versão do pacote, enquanto usa o mesmo diretório de compilação. Isso evita arquivos obsoletos e remanescentes de serem carregados para novas compilações:
$ makepkg --clean
Para mais informações, veja .
Dicas e truques
Reduzir tempos de download e extração de fontes
Faça uso de SRCDEST, especialmente ao compilar pacotes VCS, para economizar tempo ao adquirir e desempacotar fontes em recompilações subsequentes.
Compilando binários otimizados
Uma melhoria de desempenho do software empacotado pode ser conseguida ao habilitar otimizações do compilador para a máquina host. A desvantagem é que os binários compilados para uma arquitetura de processador específica não serão executados corretamente em outras máquinas. Nas máquinas x86_64, raramente existem ganhos de desempenho reais significativos que justificariam investir o tempo para reconstruir pacotes oficiais.
No entanto, é muito fácil reduzir o desempenho usando flags de compilação "não padronizadas". Muitas otimizações de compilação só são úteis em certas situações e não devem ser aplicadas indiscriminadamente em cada pacote. A menos que dados de benchmark estejam disponíveis para provar que algo é mais rápido, há uma chance muito boa de não ser! Os artigos da wiki do Gentoo otimização do GCC e CFLAGS seguras (ambos em inglês) fornecem mais informações detalhadas sobre a otimização do compilador.
As opções passadas para um compilador C/C++ (ex.: ou ) são controladas pelas variáveis de ambiente , CXXFLAGS e. Para usar o sistema de compilação do Arch, o makepkg expõe essas variáveis de ambiente como opções de configuração no makepkg.conf. Os valores padrão são configurados para produzir binários genéricos que podem ser instalados em uma ampla gama de máquinas.
O GCC pode detectar e habilitar automaticamente otimizações seguras específicas para cada arquitetura. Para usar esse recurso, primeiro remova os sinalizadores e , então adicione . Por exemplo:
Para ver quais sinalizadores isso habilita, execute:
$ gcc -march=native -v -Q --help=target
A partir do pacman versão 5.2.2, makepkg.conf também inclui substituições para a variável de ambiente , para sinalizadores fornecidos ao compilador Rust. O compilador Rust também pode detectar e habilitar otimizações específicas de arquitetura adicionando ao valor fornecido:
/etc/makepkg.conf
RUSTFLAGS="-C opt-level=2 '''-C target-cpu=native'''"
Para ver quais recursos de CPU isso vai habilitar, execute:
$ rustc -C target-cpu=native --print cfg
Executar sem irá imprimir a configuração padrão. O parâmetro pode ser alterado para , ou conforme desejado. Consulte a documentação do compilador Rust para obter detalhes.
Compilação paralela
O sistema de compilação do usa a variável de ambiente para especificar opções adicionais para o make. A variável também pode ser definida no arquivo makepkg.conf.
Os usuários com sistemas multi-core/multiprocessados podem especificar o número de trabalhos a serem executados simultaneamente. Isso pode ser realizado com o uso de nproc para determinar o número de processadores disponíveis, ex. MAKEFLAGS="-j$(nproc)". Alguns PKGBUILD substituem especificamente isso com , devido a condições de corrida em certas versões ou simplesmente porque não é suportado em primeiro lugar. Os pacotes que não conseguem ser compilados devido a isso devem ser relatados no rastreador de erros (ou no caso dos pacotes do AUR, ao mantenedor do pacote) depois de ter certeza de que o erro está sendo realmente causado pelo .
Veja para uma lista completa de opções disponíveis.
Compilando de arquivos na memória
Como a compilação requer muitas operações de E/S e lidar com arquivos pequenos, mover o diretório de trabalhos para um tmpfs pode trazer melhorias em tempos de compilação.
A variável BUILDDIR pode ser temporariamente exportada para makepkg para definir o diretório de compilação para um tmpfs existente. Por exemplo:
$ BUILDDIR=/tmp/makepkg makepkg
Uma configuração persistente pode ser feita no makepkg.conf descomentando a opção BUILDDIR, que é encontrada no fim da seção no arquivo padrão . Definir esses valores para, por exemplo, fará uso do sistema de arquivos temporário padrão do Arch.
Usando cache de compilação
O uso de ccache pode melhorar os tempos de compilação ao armazenar em cache os resultados de compilações para uso sucessivo.
Gerar novos checksums
Instale e execute o seguinte comando no mesmo diretório que o arquivo PKGBUILD para gerar novas somas de verificação (checksums):
$ updpkgsums
usa makepkg --geninteg para gerar as somas de verificação. Veja esta discussão de fórum para obter mais detalhes.
As somas de verificação também podem ser obtidos com, por exemplo, e adicionados ao vetor manualmente.
Usar outros algoritmos de compressão
Para acelerar o empacotamento e a instalação, com a consequência de ter arquivos de pacotes maiores, altere .
Por exemplo, o seguinte pula a compressão do arquivo de pacote, o qual vai, por sua vez, não ter a necessidade de descompressão na instalação:
$ PKGEXT='.pkg.tar' makepkg
Um outro exemplo abaixo mostra o uso do algoritmo lzop, com o pacote lzop necessário:
$ PKGEXT='.pkg.tar.lzo' makepkg
Para fazer uma dessas configurações permanentes, configure em .
Usando vários núcleos na compressão
O oferece suporte a multiprocessamento simétrico (SMP) por meio do sinalizador para acelerar a compressão. Por exemplo, para deixar o makepkg usar quantos núcleos de CPU for possível para comprimir os pacotes, edite o vetor em :
COMPRESSXZ=(xz -c -z --threads=0 -)
O é uma implementação paralela para o que, por padrão, usa todos os núcleos disponíveis na CPU (o sinalizador -p/--processes pode ser usado para empregar menos núcleos):
COMPRESSGZ=(pigz -c -f -n)
é um drop-in, implementação paralela para que também usa todos os núcleos de CPU disponíveis por padrão. A opção pode ser usado para empregar menos núcleos (note: nenhum espaço entre o e número de núcleos).
COMPRESSBZ2 =(pbzip2 -c -f)
zstd possui suporte a multiprocessamento simétrico (SMP) por meio do sinalizador para acelerar compressão. Por exemplo, para deixar o makepkg usar o máximo possível de núcleos de CPU para comprimir pacotes, edite o vetor em :
COMPRESSZST=(zstd -c -z -q --threads=0 -)
Mostrar pacotes com um empacotador específico
é um utilitário de extração de base de dados do pacman. Este comando mostra todos os pacotes instalados no sistema com o empacotador chamado nome-empacotador:
$ expac "%n %p" | grep "nome-empacotador" | column -t
Isso mostra todos os pacotes instalados no sistema com o empacotador definido na variável PACKAGER do . Isso mostra apenas pacotes que estão em um repositório definido em .
$ . /etc/makepkg.conf; grep -xvFf <(pacman -Qqm) <(expac "%n\t%p" | grep "$PACKAGER$" | cut -f1)
Compilar pacotes 32 bits em um sistema 64 bits
Assinatura autônoma de pacote
Uma pessoa pode não estar disponível para fornecer a senha para a chave privada gpg usada para fazer login em ambientes de compilação automatizados, como Jenkins. É desaconselhável armazenar uma chave gpg privada em um sistema sem uma senha.
Um pacote zst resultante feito com makepkg ainda pode ser assinado após a criação:
$ gpg --detach-sign --pinentry-mode loopback --passphrase --passphrase-fd 0 --output RecémCompilado.pkg.tar.zst.sig --sign RecémCompilado.pkg.tar.zst
onde a senha GPG é fornecida com segurança e obscurecida pelo seu conjunto de automação de escolha.
O arquivo zst e resultante pode ser referenciado por clientes pacman esperando uma assinatura válida e repositórios criados com ao hospedar seu próprio repositório.
URIs magnéticos
Suporte para recursos de URIs magnéticos (com prefixo ) no campo pode ser adicionado usando o agente de download .
Solução de problemas
Especificando diretório de instalação para pacotes baseados em QMAKE
O makefile gerado pelo qmake usa a variável de ambiente para especificar onde o programa deve ser instalado. Então, essa função package deve funcionar:
PKGBUILD
...
package() {
cd "$srcdir/${pkgname%-git}"
make INSTALL_ROOT="$pkgdir" install
}
...
Note que o qmake também tem que ser configurado adequadamente. Por exemplo, coloque isso no arquivo .pro correspondente:
AVISO: O pacote contém referência para $srcdir
De alguma forma, as strings literais contidas nas variáveis ou acabaram em um dos arquivos instalados no pacote.
Para identificar quais arquivos, execute o seguinte do diretório de compilação makepkg:
$ grep -R "$PWD/src" pkg/
Uma causa possível seria pelo uso da macro no código C/C++ com caminho completo passado para o compilador.
Makepkg falha em baixar dependências quando por trás de um proxy
Quando o makepkg chama dependências, ele chama o pacman para instalar os pacotes, o que requer privilégios administrativos via sudo. No entanto, o sudo não passa nenhuma variável de ambiente para o ambiente privilegiado, e inclui as variáveis relacionadas ao proxy ftp_proxy, , e .
Para que ter o makepkg funcionando por trás de um proxy, Use um dos métodos a seguir.
Habilitar proxy definindo sua URL no XferCommand
O XferCommand pode ser definido para usar a URL de proxy desejada no . Adicione ou descomente a linha a seguir no :
Habilitar proxy via env_keep do sudoers
Alternativamente, pode-se usar a opção do sudoers, a qual permite preservar as variáveis de ambiente dadas no ambiente privilegiado. Veja sudo#Variáveis de ambiente para mais informações.
Makepkg falha, mas make obtém sucesso
Se algo compilar com sucesso usando make, mas falhar através do makepkg, é quase certo que seja porque o define uma variável de compilação incompatível. Tente adicionar esses sinalizadores ao array do PKGBUILD:
!buildflags, para evitar seu , , CXXFLAGS e padrão.
!makeflags, para evitar seu padrão.
, para evitar seu e padrão, no caso do PKGBUILD ser uma compilação de depuração.
Se alguma dessas corrigir o problema, isso pode merecer um relatório de bug ao upstream, presumindo que o sinalizador ofensivo foi identificado.