# Arch User Repository (Português)

From ArchWiki
Jump to navigation Jump to search
The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.
Status de tradução: Esse artigo é uma tradução de Arch User Repository. Data da última tradução: 2021-02-25. 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

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 -si` no diretório onde os arquivos foram salvos. Isso vai baixar o código, resolver as dependências com o pacman, compilá-lo, empacotá-lo e instalar o pacote.

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`

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

    $ makepkg -si

- `-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. Alternativamente, o pacote compilado pode ser instalado com `pacman -U nome_pacote.pkg.tar.zst`.

Outras flags úteis são

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

Nota: 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, execute

    $ makepkg -si

para atualizar o pacote.

## 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 e não devem ser sinalizados como desatualizados neste caso.

## 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 no 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 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
- DeveloperWiki:AUR Cleanup Day

Categories:

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