Arch User Repository (Português)

From ArchWiki
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

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 PKGBUILDs 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 PKGBUILDs 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:

  1. 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).
  2. Certifique-se de que o PKGBUILD e os arquivos que o acompanham não são maliciosos ou duvidosos.
  3. Execute makepkg no diretório onde os arquivos foram salvos. Isso vai baixar o código, compilá-lo, empacotá-lo e instalar o pacote.
  4. 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:

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 aurvoteAUR[link quebrado: package not found], aurvote-gitAUR[link quebrado: package not found] ou aur-auto-vote-gitAUR.

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

  1. Certifique-se que seu ambiente de compilação está todo atualizado atualizando-o antes de compilar qualquer coisa.
  2. Certifique-se de ter base-devel instalado.
  3. 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.
  4. Experimente a configuração padrão do makepkg.
  5. 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 PKGBUILDs. 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 PKGBUILDs 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:

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?

Veja também