Arch User Repository (Português)

Status de tradução:
Esse artigo é uma tradução de
Arch User Repository
. Data da última tradução: 2023-08-16. Você pode ajudar a sincronizar a tradução, se houver
alterações
na versão em inglês.
Artigos relacionados
makepkg
pacman
PKGBUILD
.SRCINFO
Interface RPC do Aurweb
Diretrizes de envio ao AUR
Diretrizes de Trusted User do AUR
Repositórios oficiais
Sistema de compilação do Arch
Criando pacotes
Auxiliares do AUR
AUR Cleanup Day
O Arch User Repository (AUR) ou, em português, Repositório de Usuário do Arch é um repositório dirigido pela comunidade para usuários do Arch. Ele contém descrições de pacotes (
PKGBUILDs
) que permitem a você compilar um pacote de um fonte com o
makepkg
e depois instalar via
pacman
. O AUR foi criado para organizar e compartilhar novos pacotes da comunidade e ajudar a acelerar a inclusão dos pacotes populares no
repositório extra
. Este documento explica como usuários podem acessar e utilizar o AUR.
Um bom número de novos pacotes que entram para os repositórios oficiais iniciam no AUR. No AUR, usuários são capazes de contribuir com seus próprios pacotes (
PKGBUILD
e arquivos relacionados). A comunidade do AUR tem a capacidade de votar a favor os pacotes no AUR. Se um pacote se torna popular o bastante — desde que tenha uma licença compatível e uma boa técnica de empacotamento — ele pode ser colocado no repositório
extra
(diretamente acessível pelo
pacman
ou
abs
).
Atenção
Os pacotes do AUR são conteúdo produzido por usuário. Esses
PKGBUILD
s são completamente não oficiais e não foram completamente examinados. Qualquer uso dos arquivos fornecidos está por sua própria conta e risco.
Começando
Os usuários podem pesquisar e baixar os
PKGBUILDs
da
Interface Web do AUR
. Esses
PKGBUILD
s podem ser construídos dentro dos pacotes instaláveis usando
makepkg
, e depois instalados usando
pacman
.
Certifique-se de que
base-devel
esteja
instalado
.
Veja o
#Perguntas frequentes
para respostas das questões mais comuns.
Você pode querer ajustar
/etc/makepkg.conf
para otimizar o processo de compilação para o seu sistema antes de compilar os pacotes do AUR. Uma melhora significante nos tempos de compilação de pacotes pode ser realizada nos sistemas com processadores multi-cores ao ajustar a variável
MAKEFLAGS
, usando vários cores para compressão ou usando algoritmo de compressão diferente. Os usuários também podem habilitar otimizações de compilador específicas de hardware no
GCC
por meio da variável
CFLAGS
. Veja
makepkg
para mais informações.
Também é possível interagir com o AUR por meio de SSH: digite
ssh aur@aur.archlinux.org help
para uma lista de comandos disponíveis.
Instalando e atualizando pacotes
A instalação de pacotes do AUR é um processo relativamente simples. Essencialmente:
Obtenha os arquivos de compilação, incluindo o
PKGBUILD
e possivelmente outros arquivos necessários, como unidades
systemd
e patches (geralmente não o código em si).
Certifique-se de que o
PKGBUILD
e os arquivos que o acompanham não são maliciosos ou duvidosos.
Execute
makepkg
no diretório onde os arquivos foram salvos. Isso vai baixar o código, compilá-lo, empacotá-lo e instalar o pacote.
Execute
pacman -U
arquivo_pacote
para instalar o pacote em seu sistema.
Pré-requisitos
Primeiro, certifique-se de que as ferramentas necessárias estão
instaladas
, instalando
base-devel
. Este
metapacote
tem
make
e outras ferramentas necessárias para a compilação do código-fonte, listadas como dependências.
Nota
Os pacotes do AUR presumem que
base-devel
está instalado no ambiente  de compilação.
Em seguida, escolha o diretório de compilação adequado. Um diretório de compilação é apenas um diretório no qual o pacote será feito ou "compilado" a partir do código-fonte e pode ser em qualquer diretório. Os exemplos nas seguintes seções usarão
~/builds
como o diretório de compilação.
Obtendo arquivos de compilação
Localize o pacote no AUR. Isso pode ser feito usando o campo de pesquisa no topo da
página inicial do AUR
. Ao clicar no nome do aplicativo na lista de resultados de pesquisa, será mostrada uma página de informações sobre o pacote. Leia atentamente a descrição para confirmar que esse é o pacote desejado, veja quando o pacote foi atualizado pela última vez e leia quaisquer comentários.
Há vários métodos para adquirir os arquivos de compilação por um pacote:
Clonar seu repositório
git
, rotulado como o "Git Clone URL" em "Detalhes do pacote" em sua página do AUR. Esse é o método preferível, uma vantagem deste é que você pode facilmente obter atualizações para o pacote via
git pull
.
$ git clone https://aur.archlinux.org/
nome_pacote
.git
Baixar um snapshot, clicando no link "Baixar snapshot" sob "Ações do Pacote", no canto direito da tela em sua página do AUR, ou em um terminal:
$ curl -L -O https://aur.archlinux.org/cgit/aur.git/snapshot/
nome_pacote
.tar.gz
Nota
O arquivo de snapshot é comprimido e deve ser estraído (preferivelmente em um diretório separado para compilações do AUR):
tar -xvf
nome_pacote
.tar.gz
Use o espelho somente leitura
archlinux/aur no GitHub
, onde cada pacote está localizado em uma branch. Recomenda-se clonar apenas um único branch (todo o repositório é muito grande e o desempenho seria baixo). Você pode fazer isso com um dos dois métodos a seguir:
Use
git clone --single-branch
:
$ git clone --branch
nome_pacote
--single-branch https://github.com/archlinux/aur.git
Faça uma
clonagem parcial
deste repositório (
git clone --depth=1
) e
adicione branches
seletivamente:
$ git clone --depth=1 https://github.com/archlinux/aur.git cd aur
$ git remote set-branches --add origin
nome_pacote
$ git fetch
$ git checkout
nome_pacote
Obtendo uma chave pública PGP se necessário
Verifique se um arquivo de assinatura no formato
.sig
ou
.asc
faz parte do array de fontes no
PKGBUILD
. Se for o caso, obtenha uma das chaves públicas listadas no array
validpgpkeys
do PKGBUILD. Consulte
makepkg (Português)#Verificação de assinatura
para obter mais informações.
Compilando o pacote
Mude diretórios para o diretório contendo o
PKGBUILD
do pacote.
$ cd
nome_pacote
Atenção
Verifique cuidadosamente o
PKGBUILD
, qualquer arquivo
.install
e quaisquer outros arquivos no repositório git do pacote para comandos maliciosos ou perigosos. Em caso de dúvida, não crie o pacote e nem
peça conselho
no fórum ou na lista de discussão. Código malicioso foi encontrado em pacotes antes.
[1]
Veja o conteúdo de todos os arquivos fornecidos. Por exemplo, para usar o paginador
less
para ver
PKGBUILD
, execute:
$ less PKGBUILD
Dica
Se você está atualizando um pacote, você pode querer olhar as mudanças desde o último commit.
Para ver as mudanças desde o último commit, você pode usar
git show
.
Para ver mudanças desde o último commit usando
vimdiff
, execute
git difftool @~..@ vimdiff
. A vantagem do
vimdiff
é que você vê todo o conteúdo de cada arquivo junto com os indicadores do que foi alterado.
Crie o pacote. Depois de confirmar, manualmente, o conteúdo dos arquivos, execute
makepkg
como usuário normal no diretório de compilação. Algumas opções úteis:
-s
/
--syncdeps
resolve automaticamente e instala quaisquer dependências com o
pacman
antes de compilar. Se o pacote depende de outros pacotes do AUR, você precisará instalá-los manualmente primeiro.
-i
/
--install
instala o pacote se ele foi compilado com sucesso. Isso permite que você pule a próxima etapa que é geralmente feita manualmente.
-r
/
--rmdeps
remove dependências de tempo de compilação após a compilação, já que elas não mais são necessárias. Porém, essas dependências pode precisar serem reinstaladas da próxima vez que o pacote for atualizado.
-c
/
--clean
limpa os arquivos temporários de compilação após a compilação, já que eles não mais são necessários. Esses arquivos geralmente são necessários apenas ao depurar o processo de compilação.
Dica
Use
git clean -dfx
para excluir todos os arquivos que não est pelo git, de forma a excluir todos os arquivos de pacote anteriormente compilados.
Instalando o pacote
O pacote pode agora ser instalado com o pacman:
# pacman -U
nome_pacote
-
versão
-
arquitetura
.pkg.tar.zst
Nota
Se você alterou seu
PKGEXT
no
makepkg.conf
, o nome do arquivo de pacote pode ser um pouco diferente.
O exemplo acima é apenas um resumo breve do processo de compilação. É
altamente
recomendado ler os artigos
makepkg
e
ABS
para mais detalhes.
Obtendo fontes atualizadas dos pacotes
No diretório contendo o
PKGBUILD
do pacote, você deve primeiro atualizar os arquivos e alterações usando o comando
$ git pull
então, siga as instruções de compilação acima.
Atualizando pacotes
Não há suporte aos pacotes do AUR, então qualquer pacote que você instalar é
sua responsabilidade
atualizar, e não do pacman. Se os pacotes nos repositórios oficiais são atualizados, você vai precisar recompilar quaisquer pacotes do AUR que dependam daquelas bibliotecas.
Status da conta
Suspensão
Ao editar um usuário como um Trusted User, o campo Suspenso pode ser definido, o que suspende o usuário alvo.
Quando um usuário é suspenso, ele não consegue:
Se autenticar no
https://aur.archlinux.org
Receber notificações
Interagir com a interface git
Inatividade
Ao editar sua própria conta ou outra como Trusted User, o campo Inativo pode ser definido. As contas inativas são usadas por dois motivos:
Exibir a data em que alguém foi marcado como inativo na página da conta
Gerar uma contagem atual de usuários confiáveis ativos com base em sua inatividade para novas propostas
Feedback
Comentando em pacotes
A
Interface Web do AUR
possui um recurso de comentários que permite aos usuários fornecer sugestões e feedback sobre melhorias para o colaborador do
PKGBUILD
.
Dica
Evite colar patches ou
PKGBUILD
na seção de comentários: eles rapidamente se tornam obsoletos e acabam desnecessariamente ocupando muito espaço. Em vez disso, envie esses arquivos por e-mail para o mantenedor, ou até mesmo use um
pastebin
.
Python-Markdown
fornece sintaxe básica de
Markdown
para formatar comentários.
Nota
Esta implementação possui algumas pequenas
diferenças
em relação às
regras de sintaxe
oficiais.
Hashes de commit para o repositório
Git
do pacote e referências aos chamados no
Flyspray
são convertidas em links automaticamente.
Comentários longos são recolhidos e podem ser expandidos sob demanda.
Votando em pacotes
Uma das atividades mais fáceis para
todos
os usuários do Arch é navegar no AUR e
votar
nos seus pacotes favoritos usando a interface online. Todos os pacotes são elegíveis para adoção por uma TU para inclusão no
repositório extra
, e a contagem de votos é uma das considerações nesse processo; é do interesse de todos votar!
Inscreva-se no
site do AUR
para obter uma opção "Votar neste pacote" enquanto navega nos pacotes. Depois de se inscrever, também é possível votar na linha de comando com
aurvote
AUR
[
link quebrado
: package not found]
,
aurvote-git
AUR
[
link quebrado
: package not found]
ou
aur-auto-vote-git
AUR
.
Como alternativa, se você tiver configurado as
autenticação via ssh
, poderá votar diretamente na linha de comando usando a chave ssh. Isso significa que você não precisará salvar ou digitar sua senha do AUR.
$ ssh aur@aur.archlinux.org vote
nome_do_pacote
Sinalizando pacotes como desatualizados
Primeiro, você deve sinalizar o pacote como
desatualizado
indicando detalhes sobre o motivo pelo qual o pacote está desatualizado, de preferência incluindo links para o anúncio de lançamento ou a nova versão
tarball
.
Você também deve tentar entrar em contato com o mantenedor diretamente por e-mail. Se não houver resposta do mantenedor após
duas semanas
, você pode preencher uma requisição para
tornar órfão
. Veja
Diretrizes de envio ao AUR#Requisições
para detalhes.
Nota
Pacotes VCS
não são considerados desatualizados quando o
pkgver
muda, então não sinalize-os como desatualizados porque o mantenedor vai simplesmente retirar a sinalização do pacote e ignorar você. Mantenedores do AUR não devem fazer commit para meramente incrementar
pkgver
.
Depurando o processo de compilação de pacotes
Certifique-se que seu ambiente de compilação está todo atualizado
atualizando-o
antes de compilar qualquer coisa.
Certifique-se de ter
base-devel
instalado.
Use a opção
-s
com
makepkg
para verificar e instalar todas as dependências necessárias antes de iniciar o processo de compilação.
Experimente a
configuração padrão do makepkg
.
Consulte
Makepkg (Português)#Solução de problemas
para problemas comuns.
Se você estiver tendo problemas em compilar um pacote, primeiro leia seu
PKGBUILD
e os comentários na página AUR do pacote em questão.
É possível que o
PKGBUILD
esteja quebrado para todos. Se você não conseguir descobrir sozinho, relate-o ao mantenedor (por exemplo,
publicando os erros que você está recebendo nos comentários na página do AUR
). Você também pode procurar ajuda no
fórum AUR Issues, Discussion & PKGBUILD Requests
.
O motivo pode não ser trivial.
CFLAGS
,
LDFLAGS
e
MAKEFLAGS
personalizadas podem causar falhas. Para evitar problemas causados pela configuração específica do sistema, crie pacotes em um
chroot limpo
. Se o processo de compilação ainda falhar em um chroot limpo, o problema provavelmente está no
PKGBUILD
.
Veja
Criando pacotes#Verificando sanidade do pacote
sobre o uso do
namcap
. Se você gostaria de ter seu
PKGBUILD
revisado, poste-o na
lista de discussão aur-general
para obter feedback dos TUs e colegas membros do AUR, ou no
fórum Creating & Modifying Packages
. Você também pode obter ajuda no
canal IRC
#archlinux-aur
na rede
Libera Chat
.
Enviando pacotes
Os usuários podem compartilhar
PKGBUILDs
usando o Arch User Repository. Veja
Diretrizes de envio ao AUR
para mais detalhes.
Tradução da interface web
Veja
i18n.txt
na área de fontes do AUR para informações sobre criação e manutenção da
Interface Web do AUR
.
História
No começo, havia
ftp://ftp.archlinux.org/incoming
e as pessoas contribuíam simplesmente enviando o
PKGBUILD
, os arquivos suplementares e o próprio pacote construído para o servidor. O pacote e os arquivos associados eram mantidos lá até um
mantenedor de pacote
ver o programa e adotá-lo.
Em seguida, os Trusted User Repositories nasceram. Certos indivíduos na comunidade foram habilitados a hospedar seus próprios repositórios para qualquer um usar. O AUR expandiu nesta base, com o objetivo de ser mais flexível e usável. Na verdade, os mantenedores do AUR ainda são referidos como TUs (Trusted Users).
Entre 2015-06-08 e 2015-08-08, o AUR mudou da versão 3.5.1 para 4.0.0, introduzindo o uso de repositórios Git para publicação dos
PKGBUILD
s.
Os pacotes existentes foram descartados, a menos que migrados manualmente para a nova infraestrutura por seus mantenedores.
Repositórios Git para pacotes AUR3
O
AUR Archive
no GitHub possui um repositório para cada repositório que estava no AUR 3 durante a migração.
Alternativamente, há o repositório
aur3-mirror
que fornece o mesmo conteúdo.
Perguntas frequentes
Que tipo de pacote é permitido no AUR?
Os pacotes no AUR são apenas "scripts de compilação", ou seja, receitas para construir binários para
pacman
. Na maioria dos casos, tudo é permitido, sujeito a
utilidade e diretrizes de escopo
, desde que você esteja em conformidade com os termos de licenciamento do conteúdo. Para outros casos, onde é mencionado que "você não pode vincular" a downloads, ou seja, conteúdos que não são redistribuíveis, você pode usar apenas o nome do arquivo como fonte. Isso significa e exige que os usuários já tenham a fonte restrita no diretório de compilação antes de criar o pacote. Em caso de dúvida, pergunte.
Como posso votar em pacotes no AUR?
Veja
#Votando em pacotes
.
O que é um Trusted User / TU?
Um
Trusted User
, abreviado como TU, é uma pessoa que é escolhida para supervisionar o AUR e o
repositório extra
. Eles são os que mantêm
PKGBUILDs
populares no
extra
e de forma geral mantêm o AUR funcionando.
Qual é a diferença entre o Arch User Repository e repositório [extra]?
O Arch User Repository é onde todos os
PKGBUILDs
enviados pelos usuários são armazenados e devem ser criados manualmente com
makepkg
. Quando
PKGBUILD
s recebem bastante interesse da comunidade e o suporte de uma TU, eles são movidos para o
repositório extra
(mantido pelos TUs), onde os pacotes binários podem ser instalados com
pacman
.
Foo no AUR está desatualizado; o que devo fazer?
Veja
#Sinalizando pacotes como desatualizados
.
Neste meio tempo, você pode tentar atualizar o pacote você mesmo editando o
PKGBUILD
localmente. Ás vezes, atualizações não exigem qualquer alteração para o processo de compilação ou empacotamento, caso em que apenas atualizar o vetor
pkgver
ou
source
é suficiente.
Foo no AUR não compila quando eu executo makepkg; o que devo fazer?
Provavelmente está deixando escapar alguma coisa trivial, veja
#Depurando o processo de compilação de pacotes
.
ERRO: Uma ou mais assinaturas PGP não puderam ser verificadas!; o que eu devo fazer?
É muito provável que você não tenha as chaves públicas necessárias no seu chaveiro pessoal para verificar os arquivos baixados. Veja
Makepkg (Português)#Verificação de assinatura
para detalhes.
Como eu crio um PKGBUILD?
Consulte
Diretrizes de envio ao AUR#Regras de envio
e então veja
Criando pacotes
.
Eu tenho um PKGBUILD que queria enviar; alguém pode verificá-lo para ver se ele tem algum erro?
Há vários canais para enviar seu pacote para revisão. Veja
#Depurando o processo de compilação de pacotes
.
Como que faz para um PKGBUILD ir para o repositório
extra
?
Normalmente, pelo menos 10 votos são necessários para que algo se mova para
extra
. No entanto, se um
TU
quiser dar suporte a um pacote, ele geralmente será encontrado no repositório.
Alcançar o mínimo exigido de votos não é o único requisito, tem que haver um TU disposto a manter o pacote. Os TUs não são obrigados a mover um pacote para o repositório
extra
, mesmo que ele tenha milhares de votos.
Normalmente, quando um pacote muito popular fica no AUR, é porque:
Arch Linux já tem outra versão de um pacote nos repositórios
Sua licença proíbe redistribuição
Isso ajuda a obter
PKGBUILDs
fornecidos por usuário.
Auxiliares do AUR
, por definição,
não possuem suporte
.
Veja também as
Regras para a entrada de pacotes no repositório extra
.
Como o posso agilizar processo de repetidas compilações?
Veja
Makepkg (Português)#Melhorando os tempos de compilação
.
Qual é a diferença entre os pacotes foo e foo-git?
Muitos pacotes AUR vêm em versões de lançamento "estáveis" e "instáveis" de desenvolvimento. Pacotes de desenvolvimento geralmente têm um
sufixo
denotando
Sistema de Controle de Versão
e não se destinam ao uso comum, mas podem oferecer novos recursos ou correções de erros. Como esses pacotes só fazem o download do último fonte disponível quando você executa o
makepkg
, seu
pkgver()
no AUR no reflete as alterações no upstream. Da mesma forma, esses pacotes não podem realizar uma soma de verificação de autenticidade em qualquer
fonte VCS
.
Veja também
Manutenção do sistema#Use pacotes de software aprovados
.
Por que foo desapareceu do AUR?
É possível que o pacote tenha sido adotado por um
TU
e agora esteja no
repositório extra
.
Pacotes podem ter sido excluídos, se eles não preencherem as
regras de envio
. Veja os
histórico do aur-requests
pelo motivo da exclusão.
Nota
O repositório git para um pacote excluído geralmente fica disponível. Veja
Diretrizes de envio ao AUR#Requisições
para detalhes.
Como eu descubro se algum dos meus pacotes instalados desapareceu do AUR?
A forma mais simples é verificar o status HTTP da página AUR do pacote:
$ comm -23 <(pacman -Qqm | sort) <(curl
https://aur.archlinux.org/packages.gz
| gzip -cd | sort)
Como eu posso obter uma lista de todos os pacotes do AUR?
https://aur.archlinux.org/packages.gz
Use
aurpkglist
do
python3-aur
AUR
Veja também
Interface Web do AUR
Lista de Discussão do AUR