One place for hosting & domains

      Como Configurar um Registro Privado do Docker no Ubuntu 18.04


      O autor selecionou a Apache Software Foundation para receber uma doação como parte do programa Write for DOnations

      Introdução

      O Registro Docker é uma aplicação que gerencia o armazenamento e a entrega de imagens de container do Docker. Os registros centralizam imagens de container e reduzem o tempo de criação para desenvolvedores. As imagens do Docker garantem o mesmo ambiente de runtime por meio da virtualização, mas a criação de uma imagem pode envolver um investimento de tempo significativo. Por exemplo, em vez de instalar dependências e pacotes separadamente para usar o Docker, os desenvolvedores podem baixar uma imagem compactada de um registro que contém todos os componentes necessários. Além disso, os desenvolvedores podem automatizar o envio de imagens para um registro usando ferramentas de integração contínua, tais como o TravisCI, para atualizar continuamente as imagens durante a produção e o desenvolvimento.

      O Docker também tem um registro público gratuito, Docker Hub, que pode hospedar suas imagens personalizadas do Docker, mas há situações em que você não deseja que sua imagem fique disponível publicamente. As imagens geralmente contém todo o código necessário para executar uma aplicação, portanto, é preferível usar um registro privado ao usar um software proprietário.

      Neste tutorial, você irá configurar e proteger seu próprio Registro Docker privado. Você irá usar o Docker Compose para definir configurações para executar suas aplicações Docker e o Nginx para encaminhar o tráfego do servidor de HTTPS para o container do Docker em execução. Depois de concluir este tutorial, você poderá enviar uma imagem do Docker personalizada para seu registro privado e baixar a imagem com segurança de um servidor remoto.

      Pré-requisitos

      Antes de iniciar este guia, você precisará do seguinte:

      • Dois servidores Ubuntu 18.04 configurados seguindo a Configuração Inicial de servidor com Ubuntu 18.04, incluindo um usuário sudo não-root e um firewall. Um servidor irá hospedar seu Registro Docker privado e o outro será o seu servidor cliente.

      • Docker e Docker-Compose instalados em ambos os servidores seguindo o tutorial How To Install Docker Compose on Ubuntu 18.04. Você só precisa concluir a primeira etapa deste tutorial para instalar o Docker Compose. Este tutorial explica como instalar o Docker como parte de seus pré-requisitos.

      • Nginx instalado no seu servidor de Registro Docker privado seguindo o tutoral Como Instalar o Nginx no Ubuntu 18.04.

      • Nginx protegido com o Let’s Encrypt em seu servidor de Registro Docker privado, seguindo o tutorial Como Proteger o Nginx com o Let’s Encrypt no Ubuntu 18.04. Certifique-se de redirecionar todo o tráfego de HTTP para HTTPS no Passo 4.

      • Um nome de domínio que resolve para o servidor que você está usando para o Registro de Docker privado. Você configurará isso como parte do pré-requisito para o Let’s Encrypt.

      Passo 1 — Instalando e Configurando o Registro Docker

      A ferramenta de linha de comando do Docker é útil para iniciar e gerenciar um ou dois containers Docker, mas, para um deployment completo, a maioria das aplicações em execução dentro de containers do Docker exige que outros componentes sejam executados em paralelo. Por exemplo, muitas aplicações web consistem em um servidor web, como o Nginx, que oferece e serve o código da aplicação, uma linguagem de script interpretada, como o PHP, e um servidor de banco de dados, como o MySQL.

      Com o Docker Compose, você pode escrever um arquivo .yml para definir a configuração de cada container e as informações que os containers precisam para se comunicarem uns com os outros. Você pode usar a ferramenta de linha de comando docker-compose para emitir comandos para todos os componentes que compõem a sua aplicação.

      O próprio Registro Docker é uma aplicação com vários componentes, portanto, você utilizará o Docker Compose para gerenciar sua configuração. Para iniciar uma instância do registro, você irá configurar um arquivo docker-compose.yml para definir o local onde seu registro armazenará seus dados.

      No servidor que você criou para hospedar seu Registro Docker privado, você pode criar um diretório docker-registry, mover-se para ele, e criar uma subpasta data com os seguintes comandos:

      • mkdir ~/docker-registry && cd $_
      • mkdir data

      Use o seu editor de texto para criar o arquivo de configuração docker-compose.yml:

      Adicione o seguinte conteúdo ao arquivo, que descreve a configuração básica para o Registro Docker:

      docker-compose.yml

      version: '3'
      
      services:
        registry:
          image: registry:2
          ports:
          - "5000:5000"
          environment:
            REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data
          volumes:
            - ./data:/data
      

      A seção environment define uma variável de ambiente no container do Registro Docker com o caminho /data. A aplicação do Registro Docker verifica essa variável de ambiente quando é inicializada e, como resultado, começa a salvar seus dados na pasta /data.

      No entanto, como você incluiu a linha volumes: - ./data:/data, e o Docker irá começar a mapear o diretório /data daquele container para /data em seu servidor de registro. O resultado final é que os dados do Registro Docker são armazenados em ~/docker-registry/data no servidor do registro.

      A seção ports, com a configuração 5000:5000, diz ao Docker para mapear a porta 5000 no servidor para a porta 5000 no container em execução. Isso lhe permite enviar uma solicitação para a porta 5000 no servidor, e ter essa solicitação encaminhada para a aplicação do registro.

      Agora você pode iniciar o Docker Compose para verificar a configuração:

      Você verá barras de download em sua saída que mostram o Docker baixando a imagem do Registro Docker do próprio Docker Registry. Em um ou dois minutos, você verá uma saída semelhante à seguinte (as versões podem variar):

      Output of docker-compose up

      Starting docker-registry_registry_1 ... done Attaching to docker-registry_registry_1 registry_1 | time="2018-11-06T18:43:09Z" level=warning msg="No HTTP secret provided - generated random secret. This may cause problems with uploads if multiple registries are behind a load-balancer. To provide a shared secret, fill in http.secret in the configuration file or set the REGISTRY_HTTP_SECRET environment variable." go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2 registry_1 | time="2018-11-06T18:43:09Z" level=info msg="redis not configured" go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2 registry_1 | time="2018-11-06T18:43:09Z" level=info msg="Starting upload purge in 20m0s" go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2 registry_1 | time="2018-11-06T18:43:09Z" level=info msg="using inmemory blob descriptor cache" go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2 registry_1 | time="2018-11-06T18:43:09Z" level=info msg="listening on [::]:5000" go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2

      Você abordará a mensagem de aviso No HTTP secret provided posteriormente neste tutorial. A saída mostra que o container está iniciando. A última linha da saída mostra que ele começou a escutar com sucesso na porta 5000.

      Por padrão, o Docker Compose permanecerá aguardando sua entrada, então pressione CTRL+C para encerrar seu container do Registro Docker.

      Você configurou um Registro Docker completo, escutando na porta 5000. Nesse ponto, o registro não será iniciado, a menos que você o faça manualmente. Além disso, o Registro Docker não vem com nenhum mecanismo de autenticação integrado, por isso está atualmente inseguro e completamente aberto ao público. Nos passos quem seguem, você abordará essas preocupações de segurança.

      Passo 2 — Configurando o Encaminhamento de Porta no Nginx

      Você já tem HTTPS configurado em seu servidor de Registro Docker com Nginx, o que significa que agora você pode configurar o encaminhamento de porta do Nginx para a porta 5000. Depois de concluir esta etapa, você pode acessar seu registro diretamente em example.com.

      Como parte do pré-requisito para o guia Como Proteger o Nginx com o Let's Encrypt no Ubuntu 18.04, você já configurou o arquivo /etc/nginx/sites-available/example.com contendo a configuração do seu servidor.

      Abra o arquivo com seu editor de texto:

      sudo nano /etc/nginx/sites-available/example.com
      

      Encontre a linha location existente. Isso parecerá assim:

      /etc/nginx/sites-available/example.com

      ...
      location / {
        ...
      }
      ...
      

      Você precisa encaminhar o tráfego para a porta 5000, onde seu registro estará em execução. Você também deseja anexar cabeçalhos à solicitação para o registro, que fornecem informações adicionais do servidor com cada solicitação e resposta. Exclua o conteúdo da seção location e inclua o seguinte conteúdo nessa seção:

      /etc/nginx/sites-available/example.com

      ...
      location / {
          # Do not allow connections from docker 1.5 and earlier
          # docker pre-1.6.0 did not properly set the user agent on ping, catch "Go *" user agents
          if ($http_user_agent ~ "^(docker/1.(3|4|5(?!.[0-9]-dev))|Go ).*$" ) {
            return 404;
          }
      
          proxy_pass                          http://localhost:5000;
          proxy_set_header  Host              $http_host;   # required for docker client's sake
          proxy_set_header  X-Real-IP         $remote_addr; # pass on real client's IP
          proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
          proxy_set_header  X-Forwarded-Proto $scheme;
          proxy_read_timeout                  900;
      }
      ...
      

      A seção $http_user_agent verifica se a versão do Docker do cliente está acima de 1.5 e garante que o UserAgent não seja uma aplicação Go. Como você está usando a versão 2.0 do registro, os clientes mais antigos não são suportados. Para mais informações, você pode encontrar a configuração do cabeçalho do nginx em Docker's Registry Nginx guide.

      Salve e saia do arquivo. Aplique as alterações reiniciando o Nginx:

      • sudo service nginx restart

      Você pode confirmar que o Nginx está encaminhando o tráfego para a porta 5000 executando o registro:

      • cd ~/docker-registry
      • docker-compose up

      Em uma janela do navegador, abra a seguinte URL:

      https://example.com/v2
      

      Você verá um objeto JSON vazio, ou:

      {}
      

      No seu terminal, você verá uma saída semelhante à seguinte:

      Output of docker-compose up

      registry_1 | time="2018-11-07T17:57:42Z" level=info msg="response completed" go.version=go1.7.6 http.request.host=cornellappdev.com http.request.id=a8f5984e-15e3-4946-9c40-d71f8557652f http.request.method=GET http.request.remoteaddr=128.84.125.58 http.request.uri="/v2/" http.request.useragent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/604.4.7 (KHTML, like Gecko) Version/11.0.2 Safari/604.4.7" http.response.contenttype="application/json; charset=utf-8" http.response.duration=2.125995ms http.response.status=200 http.response.written=2 instance.id=3093e5ab-5715-42bc-808e-73f310848860 version=v2.6.2 registry_1 | 172.18.0.1 - - [07/Nov/2018:17:57:42 +0000] "GET /v2/ HTTP/1.0" 200 2 "" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/604.4.7 (KHTML, like Gecko) Version/11.0.2 Safari/604.4.7"

      Você pode ver da última linha que uma requisição GET foi feita para /v2/, que é o endpoint para o qual você enviou uma solicitação do seu navegador. O container recebeu a solicitação que você fez, do encaminhamento de porta, e retornou uma resposta de {}. O código 200 na última linha da saída significa que o container tratou a solicitação com sucesso.

      Agora que você configurou o encaminhamento de porta, é possível melhorar a segurança do seu registro.

      Passo 3 — Configurando a Autenticação

      Com o Nginx fazendo proxy das solicitações corretamente, agora você pode proteger seu registro com autenticação HTTP para gerenciar quem tem acesso ao seu Registro Docker. Para conseguir isso, você irá criar um arquivo de autenticação com o htpasswd e adicionará usuários a ele. A autenticação HTTP é rápida de configurar e segura em uma conexão HTTPS, que é o que o registro usará.

      Você pode instalar o pacote htpasswd executando o seguinte:

      • sudo apt install apache2-utils

      Agora você irá criar o diretório onde você armazenará nossas credenciais de autenticação e irá se mover para esse diretório. O $_ expande para o último argumento do comando anterior, neste caso ~/docker-registry/auth:

      • mkdir ~/docker-registry/auth && cd $_

      Em seguida, você irá criar o primeiro usuário da seguinte forma, substituindo nome_usuário pelo nome de usuário que deseja usar. A flag -B especifica criptografia bcrypt, que é mais segura que a criptografia padrão. Digite a senha quando solicitado:

      • htpasswd -Bc registry.password nome_usuário

      Nota: Para adicionar mais usuários execute novamente o comando anterior sem a opção -c (o c é para criar):

      • htpasswd registry.password nome_usuário

      A seguir, você irá editar o arquivo docker-compose.yml para dizer ao Docker para usar o arquivo que você criou para autenticar usuários.

      • cd ~/docker-registry
      • nano docker-compose.yml

      Você pode adicionar variáveis de ambiente e um volume para o diretório auth/ que você criou, editando o arquivo docker-compose.yml para informar ao Docker como você deseja autenticar usuários. Adicione o seguinte conteúdo destacado ao arquivo:

      docker-compose.yml

      version: '3'
      
      services:
        registry:
          image: registry:2
          ports:
          - "5000:5000"
          environment:
            REGISTRY_AUTH: htpasswd
            REGISTRY_AUTH_HTPASSWD_REALM: Registry
            REGISTRY_AUTH_HTPASSWD_PATH: /auth/registry.password
            REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data
          volumes:
            - ./auth:/auth
            - ./data:/data
      

      Para REGISTRY_AUTH, você especificou htpasswd, que é o esquema de autenticação que você está utilizando, e definiu REGISTRY_AUTH_HTPASSWD_PATH para o caminho do arquivo de autenticação. Finalmente, REGISTRY_AUTH_HTPASSWD_REALM significa o nome do domínio do htpasswd.

      Agora você pode verificar se sua autenticação funciona corretamente, executando o registro e verificando se ele solicita um nome de usuário e uma senha.

      Em uma janela do navegador, abra https://example.com/v2.

      Depois de digitar o nome_usuário e a senha correspondente, você verá o {} mais uma vez. Você confirmou a configuração básica da autenticação: o registro só retornou o resultado depois que você digitou o nome de usuário e a senha corretos. Agora você já protegeu seu registro e pode continuar utilizando-o.

      Passo 4 — Iniciando o Registro Docker como um Serviço

      Você quer garantir que seu registro seja iniciado sempre que o sistema for inicializado. Se houver algum travamento imprevisto do sistema, você quer ter certeza de que o registro seja reiniciado quando o servidor for reinicializado. Abra o docker-compose.yml:

      Adicione a seguinte linha de conteúdo logo abaixo de registry::

      docker-compose.yml

      ...
        registry:
          restart: always
      ...
      

      Você pode iniciar seu registro como um processo em segundo plano, o que permitirá que você saia da sessão ssh e persista o processo:

      Com o seu registro em execução em segundo plano, agora você pode preparar o Nginx para uploads de arquivos.

      Passo 5 — Aumentando o Tamanho do Upload de Arquivos para o Nginx

      Antes de poder enviar uma imagem para o registro, você precisa garantir que o registro possa lidar com grandes uploads de arquivos. Embora o Docker divida os uploads de imagens grandes em camadas separadas, às vezes elas podem ter mais de 1GB. Por padrão, o Nginx tem um limite de 1MB para uploads de arquivos, então você precisa editar o arquivo de configuração do nginx e configurar o tamanho máximo de upload do arquivo para 2GB.

      • sudo nano /etc/nginx/nginx.conf

      Encontre a seção http e adicione a seguinte linha:

      /etc/nginx/nginx.conf

      ...
      http {
              client_max_body_size 2000M;
              ...
      }
      ...
      

      Por fim, reinicie o Nginx para aplicar as alterações de configuração:

      • sudo service nginx restart

      Agora você pode enviar imagens grandes para o seu Registro Docker sem erros no Nginx.

      Passo 6 — Publicando em seu Registro Docker Privado

      Agora você está pronto para publicar uma imagem no seu Registro Docker privado, mas primeiro é preciso criar uma imagem. Para este tutorial, você criará uma imagem simples baseada na imagem ubuntu do Docker Hub. O Docker Hub é um registro hospedado publicamente, com muitas imagens pré-configuradas que podem ser aproveitadas para "Dockerizar" rapidamente as aplicações. Usando a imagem ubuntu, você vai testar o envio e o download de imagens do seu registro.

      Do seu servidor cliente, crie uma imagem pequena e vazia para enviar para o seu novo registro. As flags -i e -t lhe fornecem acesso interativo ao shell no container:

      • docker run -t -i ubuntu /bin/bash

      Após o término do download, você estará dentro de um prompt do Docker, observe que o ID do container após root@ irá variar. Faça uma rápida mudança no sistema de arquivos criando um arquivo chamado SUCCESS. No próximo passo, você poderá usar esse arquivo para determinar se o processo de publicação foi bem-sucedido:

      Saia do container do Docker:

      O comando a seguir cria uma nova imagem chamada test-image com base na imagem já em execução, além de todas as alterações que você fez. No nosso caso, a adição do arquivo /SUCCESS está incluída na nova imagem.

      Faça o commit da alteração:

      • docker commit $(docker ps -lq) test-image

      Neste ponto, a imagem só existe localmente. Agora você pode enviá-la para o novo registro que você criou. Faça o login no seu Registro Docker:

      • docker login https://example.com

      Digite o nome_usuário e a senha correspondente de antes. Em seguida, você colocará uma tag na imagem com a localização do registro privado para enviar a ele:

      • docker tag test-image example.com/test-image

      Envie a imagem recém-marcada para o registro:

      • docker push example.com/test-image

      Sua saída será semelhante à seguinte:

      Output

      The push refers to a repository [example.com/test-image] e3fbbfb44187: Pushed 5f70bf18a086: Pushed a3b5c80a4eba: Pushed 7f18b442972b: Pushed 3ce512daaf78: Pushed 7aae4540b42d: Pushed ...

      Você verificou que seu registro trata a autenticação do usuário e permite que usuários autenticados enviem imagens ao registro. Em seguida, você confirmará que também é possível extrair ou baixar imagens do registro.

      Passo 7 — Baixando de seu Registro Docker Privado

      Retorne ao seu servidor de registro para que você possa testar o download da imagem a partir do seu servidor cliente. Também é possível testar isso a partir de um outro servidor.

      Faça o login com o nome de usuário e senha que você configurou anteriormente:

      • docker login https://example.com

      Agora você está pronto para baixar a imagem. Use seu nome de domínio e nome de imagem, que você marcou na etapa anterior:

      • docker login example.com/test-image

      O Docker irá baixar a imagem e retornar você ao prompt. Se você executar a imagem no servidor de registro, verá que o arquivo SUCCESS criado anteriormente está lá:

      • docker run -it example.com/test-image /bin/bash

      Liste seus arquivos dentro do shell bash:

      Você verá o arquivo SUCCESS que você criou para esta imagem:

      SUCCESS  bin  boot  dev  etc  home  lib  lib64  media   mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
      

      Você terminou de configurar um registro seguro para o qual os usuários podem enviar e baixar imagens personalizadas.

      Conclusão

      Neste tutorial, você configurou seu próprio Registro Docker privado e publicou uma imagem Docker. Como mencionado na introdução, você também pode usar o TravisCI ou uma ferramenta de CI semelhante para automatizar o envio diretamente para um registro privado. Ao aproveitar o Docker e os registros em seu fluxo de trabalho, você pode garantir que a imagem que contém o código resulte no mesmo comportamento em qualquer máquina, seja em produção ou em desenvolvimento. Para obter mais informações sobre como escrever arquivos do Docker, você pode ler o tutorial do Docker, que explica o processo.

      Por Young Kim



      Source link

      Como Gerenciar um Banco de Dados SQL


      Um Guia de Consulta Rápida SQL

      Introdução

      Os bancos de dados SQL vêm instalados com todos os comandos necessários para adicionar, modificar, excluir e consultar seus dados. Este guia de consulta rápida fornece uma referência para alguns dos comandos SQL mais usados.

      Como Utilizar Este Guia:

      • Este guia está no formato de consulta rápida com trechos de linha de comando independentes

      • Salte para qualquer seção que seja relevante para a tarefa que você está tentando concluir

      • Quando você vir texto destacado nos comandos deste guia, tenha em mente que este texto deve se referir às colunas, tabelas e dados em seu próprio banco de dados.

      • Em todo este guia, os valores de dados de exemplo fornecidos são todos agrupados em apóstrofos ('). No SQL, é necessário envolver quaisquer valores de dados que consistam em strings em apóstrofos. Isso não é necessário para dados numéricos, mas também não causará problemas se você incluir apóstrofos.

      Por favor, observe que, embora o SQL seja reconhecido como padrão, a maioria dos programas de banco de dados SQL possui suas próprias extensões proprietárias. Este guia utiliza o MySQL como exemplo de sistema gerenciador de banco de dados relacional (SGBD), mas os comandos executados irão funcionar com outros programs de banco de dados relacionais, incluindo PostgreSQL, MariaDB, and SQLite. Onde existem diferenças significativas entre os SGDBs, incluímos os comandos alternativos.

      Abrindo o Prompt do Banco de Dados (usando Autenticação Socket/Trust)

      Por padrão no Ubuntu 18.04, o usuário root do MySQL pode se autenticar sem uma senha utilizando o seguinte comando:

      Para abrir um prompt no PostgreSQL, use o seguinte comando. Este exemplo irá logar você como o usuário postgres, que é a função de superusuário incluída, mas você pode substituir isso por qualquer função já criada:

      Abrindo o Prompt do Banco de Dados (usando Autenticação por Senha)

      Se seu usuário root do MySQL está configurado para se autenticar com uma senha, você pode fazer isso com o seguinte comando:

      Se você já tiver configurado uma conta de usuário não-root para seu banco de dados, você também poderá usar esse método para efetuar login como esse usuário:

      O comando acima irá solicitar a sua senha após executá-lo. Se voce gostaria de fornecer sua senha como parte do comando, siga imediatamente a opção -p com a sua senha, sem espaço entre elas:

      Criando um Banco de Dados

      O seguinte comando cria um banco de dados com configurações padrão.

      • CREATE DATABASE nome_do_banco_de_dados;

      Se você quer que seu banco de dados utilize um conjunto de caracteres e collation diferentes do padrão, você pode especificá-los usando esta sintaxe:

      • CREATE DATABASE nome_do_banco_de_dados CHARACTER SET character_set COLLATE collation;

      Listando Bancos de Dados

      Para ver quais bancos de dados existem em sua instalação de MySQL ou MariaDB, execute o seguinte comando:

      No PostgreSQL, você pode ver quais bancos de dados foram criados com o seguinte comando:

      Excluindo um Banco de Dados

      Para excluir um banco de dados, incluindo quaisquer tabelas e dados contidos nele, execute um comando que segue esta estrutura:

      • DROP DATABASE IF EXISTS banco_de_dados;

      Criando um Usuário

      Para criar um perfil de usuário para o seu banco de dados sem especificar nenhum privilégio para ele, execute o seguinte comando:

      • CREATE USER nome_do_usuário IDENTIFIED BY 'senha';

      O PostgreSQL usa uma sintaxe similar, mas ligeiramente diferente:

      • CREATE USER nome_do_usuário WITH PASSWORD 'senha';

      Se você quiser criar um novo usuário e conceder-lhe privilégios em um comando, você pode fazer isso usando um comando GRANT. O seguinte comando cria um novo usuário e concede a ele privilégios totais em todos os bancos de dados e tabelas do SGBD:

      • GRANT ALL PRIVILEGES ON *.* TO 'nome_do_usuário'@'localhost' IDENTIFIED BY 'senha';

      Observe a palavra-chave PRIVILEGES no comando GRANT anterior. na maioria dos SGBDs, esta palavra-chave é opcional, e esse comando pode ser escrito equivalentemente como:

      • GRANT ALL ON *.* TO 'nome_do_usuário'@'localhost' IDENTIFIED BY 'senha';

      Esteja ciente, porém, que a palavra-chave PRIVILEGES é necessária para a concessão de privilégios como este, quando o modo Strict SQL está ligado.

      Excluindo um Usuário

      Utilize a seguinte sintaxe para excluir um perfil de usuário do banco de dados:

      • DROP USER IF EXISTS nome_do_usuário;

      Observe que esse comando não excluirá por padrão nenhuma tabela criada pelo usuário excluído, e tentativas de acessar essas tabelas podem resultar em erros.

      Selecionando um Banco de Dados

      Antes de poder criar uma tabela, primeiro você precisa informar ao SGBD o banco de dados no qual você gostaria de criá-la. No MySQL e MariaDB, faça isto com a seguinte sintaxe:

      No PostgreSQL, você deve utilizar o seguinte comando para selecionar seu banco de dados desejado:

      Criando uma Tabela

      A seguinte estrutura de comando cria uma nova tabela com o nome tabela, e inclui duas colunas, cada uma com seu tipo de dado específico:

      • CREATE TABLE tabela ( coluna_1 coluna_1_tipo_de_dado, coluna_2 coluna_2_tipo_de_dado );

      Excluindo uma Tabela

      Para excluir uma tabela inteira, incluindo todos os seus dados, execute o seguinte:

      • DROP TABLE IF EXISTS tabela

      Inserindo Dados em uma Tabela

      Utilize a seguinte sintaxe para popular uma tabela com uma linha de dados:

      • INSERT INTO tabela ( coluna_A, coluna_B, coluna_C ) VALUES ( 'dado_A', 'dado_B', 'dado_C' );

      Você pode também popular uma tabela com várias linhas de dados usando um único comando, assim:

      • INSERT INTO tabela ( coluna_A, coluna_B, coluna_C ) VALUES ( 'dado_1A', 'dado_1B', 'dado_1C' ), ( 'dado_2A', 'dado_2B', 'dado_2C' ), ( 'dado_3A', 'dado_3B', 'dado_3C' );

      Excluindo Dados de uma Tabela

      Para excluir uma linha de dados de uma tabela, utilize a seguinte estrutura de comando. Observe que valor deve ser o valor contido na coluna especificada na linha que você quer excluir:

      • DELETE FROM tabela WHERE coluna='valor';

      Nota: Se você não incluir uma cláusula WHERE em um comando DELETE como no exemplo seguinte, ele excluirá todos os dados contidos em uma tabela, mas não as colunas ou a própria tabela:

      Alterando Dados em uma Tabela

      Use a seguinte sintaxe para atualizar os dados contidos em uma dada linha. Observe que a cláusula WHERE no final do comando informa ao SQL qual linha atualizar. valor é o valor contido na coluna_A que se alinha com a linha que você deseja alterar.

      Nota: Se você deixar de incluir uma cláusula WHERE em um comando UPDATE, o comando substituirá os dados contidos em todas as linhas da tabela.

      • UPDATE tabela SET coluna_1 = valor_1, coluna_2 = valor_2 WHERE coluna_A=valor;

      Inserindo uma Coluna

      A seguinte sintaxe de comando adicionará uma nova coluna a uma tabela:

      • ALTER TABLE tabela ADD COLUMN tipo_de_dado coluna;

      Excluindo uma Coluna

      Um comando seguindo essa estrutura excluirá uma coluna de uma tabela:

      • ALTER TABLE tabela DROP COLUMN coluna;

      Realizando Consultas Básicas

      Para visualizar todos os dados de uma única coluna em uma tabela, use a seguinte sintaxe:

      • SELECT coluna FROM tabela;

      Para consultar várias colunas da mesma tabela, separe os nomes das colunas com uma vírgula:

      • SELECT coluna_1, coluna_2 FROM tabela;

      Você também pode consultar todas as colunas de uma tabela, substituindo os nomes das colunas por um asterisco (*). No SQL, asteriscos agem como um curinga para representar "todos":

      Usando Cláusulas WHERE

      Você pode restringir os resultados de uma consulta adicionando a cláusula WHERE ao comando SELECT, assim:

      • SELECT coluna FROM tabela WHERE condições_que_se_aplicam;

      Por exemplo, você pode consultar todos os dados de uma única linha com uma sintaxe como a seguinte. Observe que valor deve ser um valor contido tanto na coluna especificada quanto na linha que você quer consultar:

      • SELECT * FROM tabela WHERE coluna = valor;

      Um operador de comparação em uma cláusula WHERE define como a coluna especificada deve ser comparada com o valor. Aqui estão alguns operadores comuns de comparação SQL:

      Operador O que ele faz
      = testa a igualdade
      != testa a desigualdade
      < testa menor que
      > testa maior que
      <= testa menor que ou igual a
      >= testa maior que ou igual a
      BETWEEN testa se um valor está dentro de um determinado intervalo
      IN testa se o valor de uma linha está contido em um conjunto de valores especificados
      EXISTS testa se existem linhas, dadas as condições especificadas
      LIKE testa se um valor corresponde a uma string especificada
      IS NULL testa valores NULL
      IS NOT NULL testa todos os valores que não sejam NULL

      O SQL permite o uso de caracteres curinga. Eles são úteis se você estiver tentando encontrar uma entrada específica em uma tabela, mas não tiver certeza de qual é exatamente essa entrada.

      Asteriscos (*) são marcadores que representam “todos”. Isso irá consultar todas as colunas de uma tabela:

      O símbolo de porcentagem (%) representa zero ou mais caracteres desconhecidos.

      • SELECT * FROM tabela WHERE coluna LIKE val%;

      Os underscores (_) são usados para representar um único caractere desconhecido:

      • SELECT * FROM tabela WHERE coluna LIKE v_lue;

      Contando Entradas em uma Coluna

      A função COUNT é utilizada para encontrar o número de entradas em uma determinada coluna. A seguinte sintaxe retornará o número total de valores contidos em coluna:

      • SELECT COUNT(coluna) FROM tabela;

      Você pode restringir os resultados de uma função COUNT adicionando a cláusula WHERE, assim:

      • SELECT COUNT(coluna) FROM table WHERE coluna=valor;

      Encontrando o Valor Médio em uma Coluna

      A função AVG é usada para encontrar o valor médio (nesse caso, a média) entre os valores contidos em uma coluna específica. Observe que a função AVG só funcionará com colunas contendo valores numéricos; quando usada em uma coluna contendo valores de string, pode retornar um erro ou 0:

      • SELECT AVG(coluna) FROM tabela;

      Encontrando a Soma de Valores em uma Coluna

      A função SUM é usado para encontrar a soma total de todos os valores numéricos contidos em uma coluna:

      • SELECT SUM(coluna) FROM tabela;

      Assim como na função AVG, se você executar a função SUM em uma coluna contendo valores de string, ela pode retornar um erro ou apenas 0, dependendo do seu SGBD.

      Encontrando o Maior Valor em uma Coluna

      Para encontrar o maior valor numérico em uma coluna ou o último valor em ordem alfabética, utilize a função MAX:

      • SELECT MAX(coluna) FROM tabela;

      Encontrando o Menor Valor em uma Coluna

      Para encontrar o menor valor numérico em uma coluna ou o primeiro valor em ordem alfabética, use a função MIN:

      • SELECT MIN(coluna) FROM tabela;

      Uma cláusula ORDER BY é usada para ordenar os resultados da consulta. A seguinte sintaxe de consulta retorna os valores de coluna1 e coluna2 e ordena os resultados pelos valores contidos em coluna_1 em ordem crescente ou, para valores de string, em ordem alfabética:

      • SELECT coluna_1, coluna_2 FROM tabela ORDER BY coluna_1;

      Para realizar a mesma ação, mas ordenar os resultados em ordem alfabética decrescente ou reversa, anexe a consulta com DESC:

      • SELECT coluna_1, coluna_2 FROM tabela ORDER BY coluna_1 DESC;

      A cláusula GROUP BY é semelhante à cláusula ORDER BY, mas é usada para ordenar os resultados de uma consulta que inclui uma função de agregação, como COUNT, MAX, MIN, ou SUM. Sozinhas, as funções de agregação descritas na seção anterior retornarão apenas um único valor. No entanto, você pode visualizar os resultados de uma função de agregação executada em cada valor correspondente em uma coluna, ao incluir uma cláusula GROUP BY.

      A seguinte sintaxe contará o número de valores correspondentes em coluna_2 e os agrupará em ordem crescente ou alfabética:

      • SELECT COUNT(coluna_1), coluna_2 FROM tabela GROUP BY coluna_2;

      Para realizar a mesma ação, mas ordenar os resultados em ordem alfabética decrescente ou reversa, adicione DESC à consulta:

      • SELECT COUNT(coluna_1), coluna_2 FROM tabela GROUP BY coluna_2 DESC;

      As cláusulas JOIN são usadas para criar result-sets ou conjuntos de resultados que combinam linhas de duas ou mais tabelas. Uma cláusula JOIN só funcionará se as duas tabelas tiverem uma coluna com nome e tipo de dados idênticos, como neste exemplo:

      • SELECT tabela_1.coluna_1, tabela_2.coluna_2 FROM tabela_1 JOIN tabela_2 ON tabela_1.coluna_comum=tabela_2.coluna_comum;

      Este é um exemplo de uma cláusula INNER JOIN. Um INNER JOIN retornará todos os registros que tiverem valores correspondentes nas duas tabelas, mas não mostrará registros que não tenham valores correspondentes.

      É possível retornar todos os registros de uma das duas tabelas, incluindo valores que não têm ocorrência correspondente na outra tabela, utilizando uma cláusula outer JOIN. As cláusulas outer JOIN são escritas ou como LEFT JOIN ou RIGHT JOIN.

      Uma cláusula LEFT JOIN retorna todos os registros da tabela da "esquerda" e apenas os registros correspondentes da tabela da "direita". No contexto das cláusulas outer JOIN, a tabela da esquerda é aquela referenciada na cláusula FROM, e a tabela da direita é qualquer outra tabela referenciada após a declaração JOIN. A consulta seguinte mostrará todos os registros de tabela_1 e apenas os valores correspondentes de tabela_2. Quaisquer valores que não tenham uma correspondência em tabela_2 aparecerão como NULL no result-set:

      • SELECT tabela_1.coluna_1, tabela_2.coluna_2 FROM tabela_1 LEFT JOIN tabela_2 ON tabela_1.coluna_comum=tabela_2.coluna_comum;

      Uma cláusula RIGHT JOIN funciona da mesma forma que um LEFT JOIN, mas imprime todos os resultados da tabela da direita e apenas os valores correspondentes da tabela da esquerda:

      • SELECT tabela_1.coluna_1, tabela_2.coluna_2 FROM tabela_1 RIGHT JOIN tabela_2 ON tabela_1.coluna_comum=tabela_2.coluna_comum;

      Um operador UNION é útil para combinar os resultados de dois (ou mais) comandos SELECT em um único result-set:

      • SELECT coluna_1 FROM tabela UNION SELECT coluna_2 FROM tabela;

      Além disso, a cláusula UNION pode combinar dois (ou mais) comandos SELECT consultando diferentes tabelas em um mesmo result-set:

      • SELECT coluna FROM tabela_1 UNION SELECT coluna FROM tabela_2;

      Conclusão

      Este guia aborda alguns dos comandos mais comuns no SQL usados para gerenciar bancos de dados, usuários e tabelas e consultar o conteúdo contido nessas tabelas. No entanto, existem muitas combinações de cláusulas e operadores que produzem result-set exclusivos. Se você está procurando um guia mais abrangente para trabalhar com SQL, recomendamos que você confira a Referência de SQL do Banco de Dados Oracle.

      Além disso, se houver comandos SQL comuns que você gostaria de ver neste guia, pergunte ou faça sugestões nos comentários abaixo.

      Por Mark Drake



      Source link

      Como Criar um Pull Request no GitHub


      Introdução

      Livre e open-source, o Git é um sistema de controle de versão distribuído que torna os projetos de software colaborativo mais gerenciáveis. Muitos projetos mantém seus arquivos em um repositório Git, e sites como o Github tornaram o compartilhamento e a contribuição para o código simples e efetiva.

      Projetos open-source que são hospedados em repositórios públicos beneficiam-se de contribuições feitas pela ampla comunidade de desenvolvedores através de pull requests, que solicitam que um projeto aceite as alterações feitas em seu repositório de código.

      Este tutorial vai guiá-lo no processo de realizar um pull request para um repositório Git através da linha de comando para que você possa contibuir com projetos de software open-source.

      Pré-requisitos

      Você deve ter o Git instalado em sua máquina local. Você pode verificar se o Git está instalado em seu computador e passar pelo processo de instalação para o seu sistema operacional, seguindo este guia.

      Você também precisará ter ou criar uma conta no GitHub. Você pode fazer isso através do website do GitHub, github.com, e pode ou efetuar login ou criar sua conta.

      Finalmente, você deve identificar um projeto de software open-source para contribuir. Você pode se familiarizar mais com os projetos open-source lendo essa introdução.

      Crie uma Cópia do Repositório

      Um repositório, ou repo para abreviar, é essencialmente a pasta principal do projeto. O repositório contém todos os arquivos relevantes do projeto, incluindo documentação, e também armazena o histórico de revisão para cada arquivo. No GitHub, os repositórios podem ter vários colaboradores e podem ser públicos ou privados.

      Para trabalhar em um projeto open-source, primeiro você precisará criar sua própria cópia do repositório. Para fazer isso, você deve fazer um fork do repositório e então fazer a clonagem dele para que você tenha uma cópia de trabalho local.

      Faça o Fork do Repositório

      Você pode fazer um fork de um repositório navegando até a URL GitHub do projeto open-source que você gostaria de contribuir.

      As URLs de repositórios GitHub irão referenciar o nome do usuário associado com o proprietário do repositório, bem como o nome do repositório. Por exemplo, DigitalOcean Community é o proprietário do repositório do projeto cloud_haiku, assim a URL GitHub para esse projeto é:

      https://github.com/do-community/cloud_haiku
      

      No exemplo acima, do-community é o nome do usuário e cloud_haiku é o nome do repositório.

      Um vez que você identificou o projeto que você gostaria de contribuir, você pode navegar até a URL, que estará formatada da seguinte forma:

      https://github.com/nome-do-usuário/repositório
      

      Ou você pode procurar o projeto usando a barra de pesquisa do GitHub.

      Quando você estiver na página principal do repositório, você verá um botão “Fork” no seu lado superior direito da página, abaixo do seu ícone de usuário:

      Clique no botão fork para iniciar o processo de fork. Dentro da janela do seu navegador, você receberá um feedback assim:

      Quando o processo estiver concluído, o seu navegador irá para uma tela semelhante à imagem do repositório acima, exceto que no topo você verá seu nome de usuário antes do nome do repositório, e na URL ela também mostrará seu nome de usuário antes do nome do repositório.

      Então, no exemplo acima, em vez de do-community / cloud_haiku na parte superior da página, você verá seu-nome-de-usuário / cloud_haiku, e a nova URL será parecida com isto:

      https://github.com/seu-nome-de-usuário/cloud_haiku
      

      Com o fork do repositório realizado, você está pronto para cloná-lo para que você tenha uma cópia de trabalho local da base de código.

      Clone o Repositório

      Para criar sua própria cópia local do repositório com o qual você gostaria de contribuir, primeiro vamos abrir uma janela de terminal.

      Vamos utilizar o comando git clone juntamente com a URL que aponta para o seu fork do repositório.

      Esta URL será semelhante à URL acima, exceto que agora ela irá terminar com .git. No exemplo do cloud_haiku acima, a URL ficará assim:

      https://github.com/seu-nome-de-usuário/cloud_haiku.git
      

      Você pode, alternativamente, copiar a URL usando o botão verde “Clone or download” da página do seu repositório que você acabou de fazer fork. Depois de clicar no botão, você poderá copiar a URL clicando no botão do fichário ao lado da URL:

      Uma vez que tenhamos a URL, estamos prontos para clonar o repositório. Para fazer isto, vamos combinar o comando git clone com a URL do repositório a partir da linha de comando em uma janela de terminal:

      • git clone https://github.com/seu-nome-de-usuário/repositório.git

      Agora que você tem uma cópia local do código, podemos passar para a criação de uma nova branch ou ramificação na qual iremos trabalhar com o código.

      Crie uma Nova Branch

      Sempre que você trabalha em um projeto colaborativo, você e outros programadores que contribuem para o repositório terão ideias diferentes para novos recursos ou correções de uma só vez. Alguns desses novos recursos não levarão tempo significativo para serem implementados, mas alguns deles estarão em andamento. Por isso, é importante ramificar o repositório para que você possa gerenciar o fluxo de trabalho, isolar seu código e controlar quais recursos serão retornados à branch principal do repositório do projeto.

      A branch principal padrão de um repositório de projeto é geralmente chamada de master branch. Uma prática comum recomendada é considerar qualquer coisa na branch master como sendo passível de se fazer o deploy para outras pessoas usarem a qualquer momento.

      Ao criar uma nova branch, é muito importante que você a crie fora da branch master. Você também deve se certificar de que o nome da sua branch é descritivo. Em vez de chamá-la de minha-branch, você deve usar frontend-hook-migration ou Corrigir erros de digitação na documentação.

      Para criar nossa branch, na nossa janela de terminal, vamos mudar nosso diretório para que estejamos trabalhando no diretório do repositório. Certifique-se de usar o nome real do repositório (como cloud_haiku) para mudar para esse diretório.

      Agora, vamos criar nossa nova branch com o comando git branch. Certifique-se de nomeá-la de maneira descritiva para que outras pessoas trabalhando no projeto entendam no que você está trabalhando.

      Agora que nossa nova branch está criada, podemos mudar para nos certificar de que estamos trabalhando nessa branch usando o comando git checkout:

      Depois de inserir o comando git checkout, você receberá a seguinte saída:

      Output

      Switched to branch nova-branch

      Alternativamente, você pode condensar os dois comandos acima, criando e mudando para a nova branch, com o seguinte comando e com a flag -b:

      • git checkout -b nova-branch

      Se você quiser mudar de volta para o master, você irá usar o comando checkout com o nome da branch master:

      O comando checkout vai lhe permitir alternar entre várias branches, para que você possa trabalhar em vários recursos de uma só vez.

      Neste ponto, agora você pode modificar arquivos existentes ou adicionar novos arquivos ao projeto em sua própria branch.

      Faça Alterações Localmente

      Depois de modificar os arquivos existentes ou adicionar novos arquivos ao projeto, você pode adicioná-los ao seu repositório local, o que podemos fazer com o comando git add. Vamos adicionar a flag -A para adicionar todas as alterações que fizemos:

      Em seguida, queremos registrar as alterações que fizemos no repositório com o comando git commit.

      A mensagem de commit é um aspecto importante da sua contribuição de código; ela ajuda os outros contribuidores a entenderem completamente a mudança que você fez, por que você fez e o quanto é importante. Adicionalmente, as mensagens de commit fornecem um registro histórico das mudanças para o projeto em geral, ajudando os futuros contribuidores ao longo do caminho.

      Se tivermos uma mensagem muito curta, podemos gravar isso com a flag -m e a mensagem entre aspas:

      • git commit -m "Corrigidos erros de digitação na documentação"

      Mas, a menos que seja uma mudança muito pequena, é bem provável que incluiremos uma mensagem de confirmação mais longa para que nossos colaboradores estejam totalmente atualizados com nossa contribuição. Para gravar esta mensagem maior, vamos executar o comando git commit que abrirá o editor de texto padrão:

      Se você gostaria de configurar seu editor de texto padrão, você pode fazê-lo com o comando git config e definir o nano como editor padrão, por exemplo:

      git config --global core.editor "nano"
      

      Ou o vim:

      • git config --global core.editor "vim"

      Depois de executar o comando git commit, dependendo do editor de texto padrão que você está usando, sua janela de terminal deve exibir um documento pronto para edição que será semelhante a este:

      GNU nano 2.0.6 File: …username/repository/.git/COMMIT_EDITMSG

      
      # Please enter the commit message for your changes. Lines starting
      # with '#' will be ignored, and an empty message aborts the commit.
      # On branch nova-branch
      # Your branch is up-to-date with 'origin/new-branch'.
      #
      # Changes to be committed:
      #       modified:   novo-recurso.py
      #
      

      Abaixo dos comentários introdutórios, você deve adicionar a mensagem de commit ao arquivo de texto.

      Para escrever uma mensagem útil no commit, você deve incluir um sumário na primeira linha com cerca de 50 caracteres. Abaixo disso, e dividido em seções de fácil entendimento, você deve incluir uma descrição que indique o motivo pelo qual você fez essa alteração, como o código funciona, e informações adicionais que irão contextualizar e esclarecer o código para que outras pessoas revisem o trabalho ao mesclá-lo. Tente ser o mais útil e proativo possível para garantir que os responsáveis pela manutenção do projeto possam entender totalmente sua contribuição.

      Depois de salvar e sair do arquivo de texto da mensagem de commit, você poderá verificar o commit que o git estará fazendo com o seguinte comando:

      Dependendo das alterações que você fez, você receberá uma saída parecida com esta:

      Output

      On branch nova-branch Your branch is ahead of 'origin/nova-branch' by 1 commit. (use "git push" to publish your local commits) nothing to commit, working directory clean

      Nesse ponto você pode usar o comando git push para fazer o push das alterações para a branch atual do repositório que você fez o fork:

      • git push --set-upstream origin nova-branch

      O comando irá lhe fornecer uma saída para que você saiba do progresso e será semelhante ao seguinte:

      Output

      Counting objects: 3, done. Delta compression using up to 4 threads. Compressing objects: 100% (2/2), done. Writing objects: 100% (3/3), 336 bytes | 0 bytes/s, done. Total 3 (delta 0), reused 0 (delta 0) To https://github.com/seu-nome-de-usuário /repositório .git a1f29a6..79c0e80 nova-branch -> <^>nova-branch< Branch nova-branch set up to track remote branch nova-branch from origin.

      Agora você pode navegar até o repositório que você fez o fork na sua página web do GitHub e alternar para a branch que você acabou de fazer push para ver as alterações que você fez diretamente no navegador.

      Nesse ponto, é possível fazer um pull request para o repositório original, mas se ainda não o fez, certifique-se de que seu repositório local esteja atualizado com o repositório upstream.

      Atualize o Repositório Local

      Enquanto você estiver trabalhando em um projeto ao lado de outros colaboradores, é importante que você mantenha seu repositório local atualizado com o projeto, pois você não deseja fazer um pull request de um código que cause conflitos. Para manter sua cópia local da base de código atualizada, você precisará sincronizar as alterações.

      Primeiro vamos passar pela configuração de um repositório remoto para o fork, e então, sincronizar o fork.

      Configure um Repositório Remoto para o Fork

      Repositórios remotos permitem que você colabore com outras pessoas em um projeto Git. Cada repositório remoto é uma versão do projeto que está hospedada na Internet ou em uma rede à qual você tem acesso. Cada repositório remoto deve ser acessível a você como somente leitura ou como leitura-gravação, dependendo dos seus privilégios de usuário.

      Para poder sincronizar as alterações feitas em um fork com o repositório original com o qual você está trabalhando, você precisa configurar um repositório remoto que faça referência ao repositório upstream. Você deve configurar o repositório remoto para o repositório upstream apenas uma vez.

      Primeiro, vamos verificar quais servidores remotos você configurou. O comando git remote listará qualquer repositório remoto que você já tenha especificado, então se você clonou seu repositório como fizemos acima, você verá pelo menos o repositório origin, que é o nome padrão fornecido pelo Git para o diretório clonado.

      A partir do diretório do repositório em nossa janela de terminal, vamos usar o comando git remote juntamente com a flag -v para exibir as URLs que o Git armazenou junto com os nomes curtos dos repositórios remotos relevantes (como em "origin"):

      Como clonamos um repositório, nossa saída deve ser semelhante a isso:

      Output

      origin https://github.com/seu-nome-de-usuário/repositório-forked.git (fetch) origin https://github.com/seu-nome-de-usuário/repositório-forked.git (push)

      Se você configurou anteriormente mais de um repositório remoto, o comando git remote -v fornecerá uma lista de todos eles.

      Em seguida, vamos especificar um novo repositório remoto upstream para sincronizarmos com o fork. Este será o repositório original do qual fizemos o fork. Faremos isso com o comando git remote add.

      • git remote add upstream https://github.com/nome-de-usuário-do-proprietário-original/repositório-original.git

      Nesse exemplo, upstream é o nome abreviado que fornecemos para o repositório remoto, já que em termos do Git, “Upstream” refere-se ao repositório do qual nós clonamos. Se quisermos adicionar um ponteiro remoto ao repositório de um colaborador, podemos fornecer o nome de usuário desse colaborador ou um apelido abreviado para o nome abreviado.

      Podemos verificar que nosso ponteiro remoto para o repositório upstream foi adicionado corretamente usando o comando git remote -v novamente a partir do diretório do repositório:

      Output

      origin https://github.com/seu-nome-de-usuário/repositório-forked.git (fetch) origin https://github.com/seu-nome-de-usuário/repositório-forked.git (push) upstream https://github.com/nome-de-usuário-do-proprietário-original/repositório-original.git (fetch) upstream https://github.com/nome-de-usuário-do-proprietário-original/repositório-original.git (push)

      Agora você pode se referir ao upstream na linha de comando em vez de escrever a URL inteira, e você está pronto para sincronizar seu fork com o repositório original.

      Sincronizando o Fork

      Depois de configurarmos um repositório remoto que faça referência ao upstream e ao repositório original no GitHub, estamos prontos para sincronizar nosso fork do repositório para mantê-lo atualizado.

      Para sincronizar nosso fork, a partir do diretório do nosso repositório local em uma janela de terminal, vamos utilizar o comando git fetch para buscar as branches juntamente com seus respectivos commits do repositório upstream. Como usamos o nome abreviado "upstream" para nos referirmos ao repositório upstream, passaremos o mesmo para o comando:

      Dependendo de quantas alterações foram feitas desde que fizemos o fork do repositório, sua saída pode ser diferente, e pode incluir algumas linhas de contagem, compactação e descompactação de objetos. Sua saída terminará de forma semelhante às seguintes linhas, mas pode variar dependendo de quantas branches fazem parte do projeto:

      Output

      From https://github.com/nome-de-usuário-do-proprietário-original/repositório-original * [new branch] master -> upstream/master

      Agora, os commits para o branch master serão armazenados em uma branch local chamada upstream/master.

      Vamos mudar para a branch master local do nosso repositório:

      Output

      Switched to branch 'master'

      Agora mesclaremos todas as alterações feitas na branch master do repositório original, que vamos acessar através de nossa branch upstream/master local, com a nossa branch master local:

      • git merge upstream/master

      A saída aqui vai variar, mas começará com Updating se tiverem sido feitas alterações, ou Already up-to-date, se nenhuma alteração foi feita desde que você fez o fork do repositório.

      A branch master do seu fork agora está em sincronia com o repositório upstream, e as alterações locais que você fez não foram perdidas.

      Dependendo do seu fluxo de trabalho e da quantidade de tempo que você gasta para fazer alterações, você pode sincronizar seu fork com o código upstream do repositório original quantas vezes isso fizer sentido para você. No entanto, você certamente deve sincronizar seu fork antes de fazer um pull request para garantir que não contribuirá com código conflitante.

      Crie um Pull Request

      Neste ponto, você está pronto para fazer um pull request para o repositório original.

      Você deve navegar até o seu repositório onde você fez o fork e pressionar o botão "New pull request" no lado esquerdo da página.

      Você pode modificar a branch na próxima tela. Em qualquer site, você pode selecionar o repositório apropriado no menu suspenso e a branch apropriada.

      Depois de ter escolhido, por exemplo, a branch master do repositório original no lado esquerdo, e a nova-branch do seu fork do lado direito, você deve ver uma tela assim:

      O GitHub vai lhe alertar de que é possível mesclar as duas branches porque não há código concorrente. Você deve adicionar um título, um comentário e, em seguida, pressionar o botão "Create pull request".

      Neste ponto, os mantenedores do repositório original decidirão se aceitam ou não o seu pull request. Eles podem solicitar que você edite ou revise seu código antes de aceitar o pull request.

      Conclusão

      Neste ponto, você enviou com êxito um pull request para um repositório de software open-source. Depois disso, você deve se certificar de atualizar e fazer um rebase do seu código enquanto espera que ele seja revisado. Os mantenedores do projeto podem pedir que você refaça seu código, então você deve estar preparado para isso.

      Contribuir para projetos de open-source - e se tornar um desenvolvedor ativo de open-source - pode ser uma experiência gratificante. Fazer contribuições regulares para o software que você usa com frequência lhe permite certificar-se de que esse software seja tão valioso para outros usuários finais quanto possível.

      Se você estiver interessado em aprender mais sobre o Git e colaborar com open-source, leia nossa série de tutoriais intitulada An Introduction to Open Source. Se você já conhece o Git e gostaria de um guia de consulta rápida, consulte “Como Usar o Git: Um Guia de Consulta Rápida.”

      Por Lisa Tagliaferri



      Source link