Tradução de capitulos para pt-br

book/04-git-server/sections/git-daemon.asc

@@ -1,34 +1,32 @@
 === Git Daemon
 
-(((serving repositories, git protocol)))
-Next we'll set up a daemon serving repositories over the ``Git'' protocol.
-This is common choice for fast, unauthenticated access to your Git data.
-Remember that since it's not an authenticated service, anything you serve over this protocol is public within its network.
+(((servindo repositórios, protocolo git)))
+Agora vamos configurar um daemon para servir repositórios através do protocolo ``Git''. Essa é uma escolha comum para acesso rápido e não autenticado aos seus dados Git.  
+Lembre-se de que, como não é um serviço autenticado, qualquer coisa que você servir através deste protocolo será pública dentro de sua rede.
 
-If you're running this on a server outside your firewall, it should only be used for projects that are publicly visible to the world.
-If the server you're running it on is inside your firewall, you might use it for projects that a large number of people or computers (continuous integration or build servers) have read-only access to, when you don't want to have to add an SSH key for each.
+Se você estiver rodando isso em um servidor fora de seu firewall, ele deve ser usado apenas para projetos que são publicamente visíveis para o mundo.  
+Se o servidor estiver dentro de seu firewall, você pode usá-lo para projetos aos quais um grande número de pessoas ou computadores (como servidores de integração contínua ou de construção) tenha acesso apenas leitura, quando você não deseja adicionar uma chave SSH para cada um deles.
 
-In any case, the Git protocol is relatively easy to set up.
-Basically, you need to run this command in a daemonized manner:(((git commands, daemon)))
+Em qualquer caso, o protocolo Git é relativamente fácil de configurar.  
+Basicamente, você precisa rodar este comando de forma daemonizada:
 
 [source,console]
 ----
 $ git daemon --reuseaddr --base-path=/srv/git/ /srv/git/
 ----
 
-`--reuseaddr` allows the server to restart without waiting for old connections to time out, the `--base-path` option allows people to clone projects without specifying the entire path, and the path at the end tells the Git daemon where to look for repositories to export.
-If you're running a firewall, you'll also need to punch a hole in it at port 9418 on the box you're setting this up on.
+`--reuseaddr` permite que o servidor reinicie sem esperar que as conexões antigas expirem, a opção `--base-path` permite que as pessoas clonem projetos sem especificar o caminho completo, e o caminho no final indica ao daemon Git onde procurar repositórios para exportar.  
+Se você estiver rodando um firewall, também precisará abrir a porta 9418 na máquina em que está configurando isso.
 
-You can daemonize this process a number of ways, depending on the operating system you're running.
-On an Ubuntu machine, you can use an Upstart script.
-So, in the following file
+Você pode daemonizar este processo de várias maneiras, dependendo do sistema operacional em que está rodando.  
+Em uma máquina Ubuntu, você pode usar um script Upstart. Então, no seguinte arquivo:
 
 [source,console]
 ----
 /etc/init/local-git-daemon.conf
 ----
 
-you put this script:
+Você coloca este script:
 
 [source,console]
 ----
@@ -42,26 +40,25 @@ exec /usr/bin/git daemon \
 respawn
 ----
 
-For security reasons, it is strongly encouraged to have this daemon run as a user with read-only permissions to the repositories – you can easily do this by creating a new user 'git-ro' and running the daemon as them.
-For the sake of simplicity we'll simply run it as the same 'git' user that `git-shell` is running as.
+Por questões de segurança, é altamente recomendável que este daemon seja executado como um usuário com permissões de apenas leitura para os repositórios – você pode facilmente fazer isso criando um novo usuário 'git-ro' e executando o daemon com esse usuário.  
+Por simplicidade, vamos executá-lo como o mesmo usuário 'git' que o `git-shell` está usando.
 
-When you restart your machine, your Git daemon will start automatically and respawn if it goes down.
-To get it running without having to reboot, you can run this:
+Quando você reiniciar a sua máquina, o Git daemon será iniciado automaticamente e será reiniciado se parar de funcionar.  
+Para iniciá-lo sem precisar reiniciar, você pode rodar o seguinte:
 
 [source,console]
 ----
 $ initctl start local-git-daemon
 ----
 
-On other systems, you may want to use `xinetd`, a script in your `sysvinit` system, or something else – as long as you get that command daemonized and watched somehow.
+Em outros sistemas, você pode querer usar `xinetd`, um script no seu sistema `sysvinit`, ou outro método – contanto que você daemonize e monitore esse comando de alguma forma.
 
-Next, you have to tell Git which repositories to allow unauthenticated Git server-based access to.
-You can do this in each repository by creating a file named `git-daemon-export-ok`.
+Agora, você precisa informar ao Git quais repositórios permitirão o acesso não autenticado via servidor Git.  
+Você pode fazer isso em cada repositório criando um arquivo chamado `git-daemon-export-ok`.
 
 [source,console]
 ----
 $ cd /path/to/project.git
 $ touch git-daemon-export-ok
 ----
-
-The presence of that file tells Git that it's OK to serve this project without authentication.
+A presença desse arquivo informa ao Git que é permitido servir este projeto sem autenticação.

book/04-git-server/sections/git-on-a-server.asc

@@ -1,100 +1,100 @@
-[[r_git_on_the_server]]
-=== Getting Git on a Server
+[r_git_on_the_server]
+=== Instalando o Git em um Servidor
 
-Now we'll cover setting up a Git service running these protocols on your own server.
+Agora vamos abordar como configurar um serviço Git em seu próprio servidor.
 
 [NOTE]
 ====
-Here we'll be demonstrating the commands and steps needed to do basic, simplified installations on a Linux based server, though it's also possible to run these services on Mac or Windows servers.
-Actually setting up a production server within your infrastructure will certainly entail differences in security measures or operating system tools, but hopefully this will give you the general idea of what's involved.
+Aqui, vamos demonstrar os comandos e passos necessários para fazer instalações básicas e simplificadas em um servidor baseado em Linux, embora seja possível rodar esses serviços também em servidores Mac ou Windows.
+A configuração de um servidor de produção dentro da sua infraestrutura certamente envolverá diferenças em medidas de segurança ou ferramentas do sistema operacional, mas esperamos que isso forneça uma ideia geral do que está envolvido.
 ====
 
-In order to initially set up any Git server, you have to export an existing repository into a new bare repository – a repository that doesn't contain a working directory.
-This is generally straightforward to do.
-In order to clone your repository to create a new bare repository, you run the clone command with the `--bare` option.(((git commands, clone, bare)))
-By convention, bare repository directories end in `.git`, like so:
+Para configurar inicialmente qualquer servidor Git, você precisa exportar um repositório existente para um novo repositório bare — um repositório que não contém um diretório de trabalho.
+Isso é geralmente simples de fazer.
+Para clonar seu repositório e criar um novo repositório bare, você executa o comando de clonagem com a opção `--bare`.(((git commands, clone, bare)))
+Por convenção, diretórios de repositórios bare terminam em `.git`, como segue:
 
 [source,console]
 ----
-$ git clone --bare my_project my_project.git
-Cloning into bare repository 'my_project.git'...
-done.
+$ git clone --bare meu_projeto meu_projeto.git
+Clonando para repositório bare 'meu_projeto.git'...
+feito.
 ----
 
-You should now have a copy of the Git directory data in your `my_project.git` directory.
+Agora você deve ter uma cópia dos dados do diretório Git no diretório `meu_projeto.git`.
 
-This is roughly equivalent to something like
+Isso é aproximadamente equivalente a algo como
 
 [source,console]
 ----
-$ cp -Rf my_project/.git my_project.git
+$ cp -Rf meu_projeto/.git meu_projeto.git
 ----
 
-There are a couple of minor differences in the configuration file; but for your purpose, this is close to the same thing.
-It takes the Git repository by itself, without a working directory, and creates a directory specifically for it alone.
+Há algumas diferenças menores no arquivo de configuração; mas para o seu propósito, isso é praticamente a mesma coisa.
+Ele pega o repositório Git sozinho, sem o diretório de trabalho, e cria um diretório especificamente para ele.
 
-[[r_bare_repo]]
-==== Putting the Bare Repository on a Server
+[r_bare_repo]
+==== Colocando o Repositório Bare em um Servidor
 
-Now that you have a bare copy of your repository, all you need to do is put it on a server and set up your protocols.
-Let's say you've set up a server called `git.example.com` that you have SSH access to, and you want to store all your Git repositories under the `/srv/git` directory.
-Assuming that `/srv/git` exists on that server, you can set up your new repository by copying your bare repository over:
+Agora que você tem uma cópia bare do seu repositório, tudo o que você precisa fazer é colocá-lo em um servidor e configurar seus protocolos.
+Vamos supor que você tenha configurado um servidor chamado `git.exemplo.com` ao qual você tem acesso SSH, e quer armazenar todos os seus repositórios Git no diretório `/srv/git`.
+Assumindo que `/srv/git` exista nesse servidor, você pode configurar seu novo repositório copiando seu repositório bare:
 
 [source,console]
 ----
-$ scp -r my_project.git user@git.example.com:/srv/git
+$ scp -r meu_projeto.git usuario@git.exemplo.com:/srv/git
 ----
 
-At this point, other users who have SSH access to the same server which has read-access to the `/srv/git` directory can clone your repository by running
+Neste ponto, outros usuários que têm acesso SSH ao mesmo servidor e que têm permissão de leitura no diretório `/srv/git` podem clonar seu repositório executando
 
 [source,console]
 ----
-$ git clone user@git.example.com:/srv/git/my_project.git
+$ git clone usuario@git.exemplo.com:/srv/git/meu_projeto.git
 ----
 
-If a user SSHs into a server and has write access to the `/srv/git/my_project.git` directory, they will also automatically have push access.
+Se um usuário acessar o servidor via SSH e tiver permissão de escrita no diretório `/srv/git/meu_projeto.git`, ele também terá automaticamente acesso para enviar alterações (push).
 
-Git will automatically add group write permissions to a repository properly if you run the `git init` command with the `--shared` option.(((git commands, init, bare)))
+O Git automaticamente adiciona permissões de escrita para o grupo corretamente se você executar o comando `git init` com a opção `--shared`.(((git commands, init, bare)))
 
 [source,console]
 ----
-$ ssh user@git.example.com
-$ cd /srv/git/my_project.git
+$ ssh usuario@git.exemplo.com
+$ cd /srv/git/meu_projeto.git
 $ git init --bare --shared
 ----
 
-You see how easy it is to take a Git repository, create a bare version, and place it on a server to which you and your collaborators have SSH access.
-Now you're ready to collaborate on the same project.
+Você vê como é fácil pegar um repositório Git, criar uma versão bare e colocá-la em um servidor ao qual você e seus colaboradores tenham acesso SSH.
+Agora você está pronto para colaborar no mesmo projeto.
 
-It's important to note that this is literally all you need to do to run a useful Git server to which several people have access – just add SSH-able accounts on a server, and stick a bare repository somewhere that all those users have read and write access to.
-You're ready to go – nothing else needed.
+É importante notar que isso é literalmente tudo o que você precisa fazer para rodar um servidor Git útil, ao qual várias pessoas tenham acesso – basta adicionar contas SSH em um servidor e colocar um repositório bare em algum lugar onde todos esses usuários tenham acesso de leitura e escrita.
+Você está pronto para começar – nada mais é necessário.
 
-In the next few sections, you'll see how to expand to more sophisticated setups.
-This discussion will include not having to create user accounts for each user, adding public read access to repositories, setting up web UIs and more.
-However, keep in mind that to collaborate with a couple of people on a private project, all you _need_ is an SSH server and a bare repository.
+Nas próximas seções, você verá como expandir para configurações mais sofisticadas.
+Esta discussão incluirá a criação de contas de usuário para cada usuário, adicionar acesso público de leitura aos repositórios, configurar interfaces web e mais.
+No entanto, tenha em mente que para colaborar com algumas pessoas em um projeto privado, tudo o que você _precisa_ é de um servidor SSH e um repositório bare.
 
-==== Small Setups
+==== Configurações Simples
 
-If you're a small outfit or are just trying out Git in your organization and have only a few developers, things can be simple for you.
-One of the most complicated aspects of setting up a Git server is user management.
-If you want some repositories to be read-only to certain users and read/write to others, access and permissions can be a bit more difficult to arrange.
+Se você é uma equipe pequena ou está apenas testando o Git em sua organização e tem apenas alguns desenvolvedores, as coisas podem ser simples para você.
+Um dos aspectos mais complicados de configurar um servidor Git é o gerenciamento de usuários.
+Se você quiser que alguns repositórios sejam apenas leitura para certos usuários e leitura/escrita para outros, o acesso e as permissões podem ser um pouco mais difíceis de arranjar.
 
-===== SSH Access
+===== Acesso SSH
 
 (((serving repositories, SSH)))
-If you have a server to which all your developers already have SSH access, it's generally easiest to set up your first repository there, because you have to do almost no work (as we covered in the last section).
-If you want more complex access control type permissions on your repositories, you can handle them with the normal filesystem permissions of the operating system your server runs.
+Se você tem um servidor ao qual todos seus desenvolvedores já têm acesso SSH, geralmente é mais fácil configurar seu primeiro repositório lá, porque você não precisa fazer quase nenhum trabalho (como vimos na seção anterior).
+Se você quiser permissões de controle de acesso mais complexas nos seus repositórios, pode gerenciá-las com as permissões de sistema de arquivos do sistema operacional que seu servidor usa.
 
-If you want to place your repositories on a server that doesn't have accounts for everyone on your team whom you want to have write access, then you must set up SSH access for them.
-We assume that if you have a server with which to do this, you already have an SSH server installed, and that's how you're accessing the server.
+Se você quiser colocar seus repositórios em um servidor que não tenha contas para todos na sua equipe que você deseja que tenham acesso de escrita, você deve configurar o acesso SSH para eles.
+Assumimos que, se você tem um servidor com o qual fazer isso, você já tem um servidor SSH instalado, e é assim que você está acessando o servidor.
 
-There are a few ways you can give access to everyone on your team.
-The first is to set up accounts for everybody, which is straightforward but can be cumbersome.
-You may not want to run `adduser` and set temporary passwords for every user.
+Existem algumas maneiras de dar acesso a todos na sua equipe.
+A primeira é configurar contas para todos, o que é direto, mas pode ser trabalhoso.
+Você pode não querer rodar `adduser` e configurar senhas temporárias para cada usuário.
 
-A second method is to create a single 'git' user on the machine, ask every user who is to have write access to send you an SSH public key, and add that key to the `~/.ssh/authorized_keys` file of your new 'git' user.
-At that point, everyone will be able to access that machine via the 'git' user.
-This doesn't affect the commit data in any way – the SSH user you connect as doesn't affect the commits you've recorded.
+Uma segunda maneira é criar um único usuário 'git' na máquina, pedir para cada usuário que deve ter acesso de escrita enviar sua chave pública SSH, e adicionar essa chave ao arquivo `~/.ssh/authorized_keys` do novo usuário 'git'.
+Nesse ponto, todos poderão acessar essa máquina através do usuário 'git'.
+Isso não afeta os dados de commit de nenhuma forma – o usuário SSH que você usa para conectar não afeta os commits registrados.
 
-Another way to do it is to have your SSH server authenticate from an LDAP server or some other centralized authentication source that you may already have set up.
-As long as each user can get shell access on the machine, any SSH authentication mechanism you can think of should work.
+Outra maneira de fazer isso é ter o servidor SSH autenticar a partir de um servidor LDAP ou alguma outra fonte de autenticação centralizada que você já tenha configurado.
+Enquanto cada usuário puder obter acesso ao shell na máquina, qualquer mecanismo de autenticação SSH que você possa imaginar deve funcionar.