Arch User Repository (Português) - ArchWiki

Jump to content
Status de tradução: Esse artigo é uma tradução de Arch User Repository. Data da última tradução: 2022-08-24. 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
- Arch Build System
- 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 community. 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 community (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 o grupo de pacotes base-devel está todo instalado (`pacman -S --needed base-devel`).
- Veja o #FAQ 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.

## 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 mantiveram-se 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 Arquivo do AUR no GitHub possui um repositório para cada repositório que estava no AUR 3 durante a migração para o AUR 4 em Agosto de 2015. Alternativamente, há o repositório aur3-mirror que fornece o mesmo conteúdo.

## 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.

Nota: Não há suporte aos pacotes do AUR, então qualquer pacote que você instalar é sua responsabilidade atualizar, e não do pacman. Se o pacote nos repositórios oficiais são atualizados, você precisa recompilar quaisquer pacotes do AUR que dependam daquelas bibliotecas.

### Pré-requisitos

Primeiro, certifique-se de que as ferramentas necessárias estão instaladas, instalando todo o grupo base-devel, o qual inclui make e outras ferramentas necessárias para a compilação do código-fonte.

Dica: Use a opção `--needed` ao instalar o grupo base-devel para ignorar pacotes que você já tem instalados, em vez de reinstalá-los.
Nota: Os pacotes do AUR presumem que o grupo base-devel está instalado, isto é, eles não listarão explicitamente os membros deste grupo como dependências 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" 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_branch/nome_pacote --single-branch https://github.com/archlinux/aur

  - 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; 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`:

    $ 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 são ignorados 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.

### Atualizando 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.

## 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 community, 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, aurvote-gitAUR 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 o grupo 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.

## FAQ

### 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 community. Eles são os que mantêm PKGBUILDs populares no community e de forma geral mantêm o AUR funcionando.

### Qual é a diferença entre o Arch User Repository e repositório [community]?

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 community (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 community?

Normalmente, pelo menos 10 votos são necessários para que algo se mova para community. 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 community, 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 [[Diretrizes de Trusted User do AUR#Regras para a Entrada de Pacotes no Repositório [community]|Regras para a Entrada de Pacotes no Repositório community]].

### 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 community.

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.

Se o pacote costumava existir no AUR3, ele pode não ter sido migrado para o AUR4. Veja os #Repositórios Git para pacotes AUR3 nos quais eles foram preservados.

### 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-aurAUR

## Veja também

- Interface Web do AUR
- Lista de Discussão do AUR

Categories:

- About Arch (Português)
- Package development (Português)
- Package management (Português)