One place for hosting & domains

      Instalar

      Como Instalar e Usar o Docker no Ubuntu 18.04


      Uma versão anterior deste tutorial foi escrita por finid.

      Introdução

      O Docker é uma aplicação que simplifica a maneira de gerenciar processos de aplicativos em containers. Os containers lhe permitem executar suas aplicações em processos com isolamento de recursos. Eles são semelhantes às máquinas virtuais, mas os containers são mais portáteis, possuem recursos mais amigáveis, e são mais dependentes do sistema operacional do host.

      Para uma introdução detalhada aos diferentes componentes de um container Docker, dê uma olhada em O Ecossistema do Docker: Uma Introdução aos Componentes Comuns.

      Neste tutorial, você irá instalar e utilizar o Docker Community Edition (CE) no Ubuntu 18.04. Você instalará o próprio Docker, trabalhará com containers e imagens, e irá enviar uma imagem para um repositório do Docker.

      Pré-requisitos

      Para seguir este tutorial, você precisará do seguinte:

      Passo 1 — Instalando o Docker

      O pacote de instalação do Docker disponível no repositório oficial do Ubuntu pode não ser a versão mais recente. Para garantir que teremos a última versão, vamos instalar o Docker a partir do repositório oficial do projeto. Para fazer isto, vamos adicionar uma nova fonte de pacotes, adicionar a chave GPG do Docker para garantir que os downloads são válidos, e então instalar os pacotes.

      Primeiro, atualize sua lista atual de pacotes:

      Em seguida, instale alguns pacotes de pré-requisitos que permitem que o apt utilize pacotes via HTTPS:

      • sudo apt install apt-transport-https ca-certificates curl software-properties-common

      Então adicione a chave GPG para o repositório oficial do Docker em seu sistema:

      • curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

      Adicione o repositório do Docker às fontes do APT:

      • sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"

      A seguir, atualize o banco de dados de pacotes com os pacotes Docker do repositório recém adicionado:

      Certifique-se de que você irá instalar a partir do repositório do Docker em vez do repositório padrão do Ubuntu:

      • apt-cache policy docker-ce

      Você verá uma saída como esta, embora o número da versão do Docker possa estar diferente:

      Output of apt-cache policy docker-ce

      
      docker-ce:
        Installed: (none)
        Candidate: 18.03.1~ce~3-0~ubuntu
        Version table:
           18.03.1~ce~3-0~ubuntu 500
              500 https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
      

      Observe que o docker-ce não está instalado, mas o candidato para instalação é do repositório do Docker para o Ubuntu 18.04 (bionic).

      Finalmente, instale o Docker:

      • sudo apt install docker-ce

      O Docker agora deve ser instalado, o daemon iniciado e o processo ativado para iniciar na inicialização. Verifique se ele está sendo executado:

      • sudo systemctl status docker

      A saída deve ser semelhante à seguinte, mostrando que o serviço está ativo e executando:

      Output

      ● docker.service - Docker Application Container Engine Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled) Active: active (running) since Thu 2018-07-05 15:08:39 UTC; 2min 55s ago Docs: https://docs.docker.com Main PID: 10096 (dockerd) Tasks: 16 CGroup: /system.slice/docker.service ├─10096 /usr/bin/dockerd -H fd:// └─10113 docker-containerd --config /var/run/docker/containerd/containerd.toml

      A instalação do Docker agora oferece não apenas o serviço Docker (daemon), mas também o utilitário de linha de comando docker ou o cliente Docker. Vamos explorar como usar o comando docker mais adiante neste tutorial.

      Passo 2 — Executando o Comando Docker sem Sudo (Opcional)

      Por padrão o comando docker só pode ser executado pelo usuário root ou por um usuário do grupo docker, que é automaticamente criado durante o processo de instalação do Docker. Se você tentar executar o comando docker sem prefixá-lo com sudo ou sem estar no grupo docker, você obterá uma saída como esta:

      Output

      docker: Cannot connect to the Docker daemon. Is the docker daemon running on this host?. See 'docker run --help'.

      Se você quiser evitar digitar sudo sempre que você executar o comando docker, adicione seu nome de usuário ao grupo docker:

      • sudo usermod -aG docker ${USER}

      Para aplicar a nova associação ao grupo, efetue logout do servidor e faça logon novamente ou digite o seguinte:

      Você será solicitado a entrar com seu usuário e senha para continuar.

      Confirme que seu usuário está agora adicionado ao grupo docker digitando:

      Output

      sammy sudo docker

      Se você precisar adicionar um usuário ao grupo docker com o qual você não está logado, declare o nome do usuário explicitamente usando:

      • sudo usermod -aG docker nome-do-usuário

      O restante desse artigo assume que você está executando o comando docker como um usuário do grupo docker. Se você optar por não fazê-lo, por favor, prefixe os comandos com sudo.

      A seguir, vamos explorar o comando docker.

      Passo 3 — Usando o Comando Docker

      A utilização do comando docker consiste em passar a ele uma cadeia de opções e comandos seguidos de argumentos. A sintaxe assume este formato:

      • docker [option] [command] [arguments]

      Para ver todos os subcomandos disponíveis, digite:

      A partir do Docker 18, a lista completa de subcomandos disponíveis inclui:

      Output

      attach Attach local standard input, output, and error streams to a running container build Build an image from a Dockerfile commit Create a new image from a container's changes cp Copy files/folders between a container and the local filesystem create Create a new container diff Inspect changes to files or directories on a container's filesystem events Get real time events from the server exec Run a command in a running container export Export a container's filesystem as a tar archive history Show the history of an image images List images import Import the contents from a tarball to create a filesystem image info Display system-wide information inspect Return low-level information on Docker objects kill Kill one or more running containers load Load an image from a tar archive or STDIN login Log in to a Docker registry logout Log out from a Docker registry logs Fetch the logs of a container pause Pause all processes within one or more containers port List port mappings or a specific mapping for the container ps List containers pull Pull an image or a repository from a registry push Push an image or a repository to a registry rename Rename a container restart Restart one or more containers rm Remove one or more containers rmi Remove one or more images run Run a command in a new container save Save one or more images to a tar archive (streamed to STDOUT by default) search Search the Docker Hub for images start Start one or more stopped containers stats Display a live stream of container(s) resource usage statistics stop Stop one or more running containers tag Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE top Display the running processes of a container unpause Unpause all processes within one or more containers update Update configuration of one or more containers version Show the Docker version information wait Block until one or more containers stop, then print their exit codes

      Para ver as opções disponíveis para um comando específico, digite:

      • docker subcomando-docker --help

      Para ver informações de sistema sobre o Docker, use:

      Vamos explorar alguns desses comandos. Vamos começar trabalhando com imagens.

      Os containers Docker são construídos a partir de imagens Docker. Por padrão, o Docker extrai essas imagens do Docker Hub, um registro Docker mantido pela Docker, a empresa por trás do projeto Docker. Qualquer pessoa pode hospedar suas imagens do Docker no Docker Hub, portanto, a maioria dos aplicativos e distribuições do Linux que você precisa terá imagens hospedadas lá.

      Para verificar se você pode acessar e baixar imagens do Docker Hub, digite:

      A saída irá indicar que o Docker está funcionando corretamente:

      Output

      Unable to find image 'hello-world:latest' locally latest: Pulling from library/hello-world 9bb5a5d4561a: Pull complete Digest: sha256:3e1764d0f546ceac4565547df2ac4907fe46f007ea229fd7ef2718514bcec35d Status: Downloaded newer image for hello-world:latest Hello from Docker! This message shows that your installation appears to be working correctly. ...

      Inicialmente, o Docker foi incapaz de encontrar a imagem hello-world localmente, então baixou a imagem do Docker Hub, que é o repositório padrão. Depois que a imagem foi baixada, o Docker criou um container a partir da imagem e o aplicativo dentro do container foi executado, exibindo a mensagem.

      Você pode procurar imagens disponíveis no Docker Hub usando o comando docker com o subcomandosearch. Por exemplo, para procurar a imagem do Ubuntu, digite:

      O script rastreará o Docker Hub e retornará uma listagem de todas as imagens cujo nome corresponde à string de pesquisa. Nesse caso, a saída será similar a essa:

      Output

      NAME DESCRIPTION STARS OFFICIAL AUTOMATED ubuntu Ubuntu is a Debian-based Linux operating sys… 7917 [OK] dorowu/ubuntu-desktop-lxde-vnc Ubuntu with openssh-server and NoVNC 193 [OK] rastasheep/ubuntu-sshd Dockerized SSH service, built on top of offi… 156 [OK] ansible/ubuntu14.04-ansible Ubuntu 14.04 LTS with ansible 93 [OK] ubuntu-upstart Upstart is an event-based replacement for th… 87 [OK] neurodebian NeuroDebian provides neuroscience research s… 50 [OK] ubuntu-debootstrap debootstrap --variant=minbase --components=m… 38 [OK] 1and1internet/ubuntu-16-nginx-php-phpmyadmin-mysql-5 ubuntu-16-nginx-php-phpmyadmin-mysql-5 36 [OK] nuagebec/ubuntu Simple always updated Ubuntu docker images w… 23 [OK] tutum/ubuntu Simple Ubuntu docker images with SSH access 18 i386/ubuntu Ubuntu is a Debian-based Linux operating sys… 13 ppc64le/ubuntu Ubuntu is a Debian-based Linux operating sys… 12 1and1internet/ubuntu-16-apache-php-7.0 ubuntu-16-apache-php-7.0 10 [OK] 1and1internet/ubuntu-16-nginx-php-phpmyadmin-mariadb-10 ubuntu-16-nginx-php-phpmyadmin-mariadb-10 6 [OK] eclipse/ubuntu_jdk8 Ubuntu, JDK8, Maven 3, git, curl, nmap, mc, … 6 [OK] codenvy/ubuntu_jdk8 Ubuntu, JDK8, Maven 3, git, curl, nmap, mc, … 4 [OK] darksheer/ubuntu Base Ubuntu Image -- Updated hourly 4 [OK] 1and1internet/ubuntu-16-apache ubuntu-16-apache 3 [OK] 1and1internet/ubuntu-16-nginx-php-5.6-wordpress-4 ubuntu-16-nginx-php-5.6-wordpress-4 3 [OK] 1and1internet/ubuntu-16-sshd ubuntu-16-sshd 1 [OK] pivotaldata/ubuntu A quick freshening-up of the base Ubuntu doc… 1 1and1internet/ubuntu-16-healthcheck ubuntu-16-healthcheck 0 [OK] pivotaldata/ubuntu-gpdb-dev Ubuntu images for GPDB development 0 smartentry/ubuntu ubuntu with smartentry 0 [OK] ossobv/ubuntu ...

      Na coluna OFFICIAL, o OK indica uma imagem construída e suportada pela empresa por trás do projeto. Depois de identificar a imagem que você gostaria de usar, você pode baixá-la para o seu computador usando o subcomando pull.

      Execute o seguinte comando para baixar a imagem oficial do ubuntu para seu computador:

      Você verá a seguinte saída:

      Output

      Using default tag: latest latest: Pulling from library/ubuntu 6b98dfc16071: Pull complete 4001a1209541: Pull complete 6319fc68c576: Pull complete b24603670dc3: Pull complete 97f170c87c6f: Pull complete Digest: sha256:5f4bdc3467537cbbe563e80db2c3ec95d548a9145d64453b06939c4592d67b6d Status: Downloaded newer image for ubuntu:latest

      Após o download de uma imagem, você pode executar um container usando a imagem baixada com o subcomando run. Como você viu com o exemplo do hello-world, se uma imagem não tiver sido baixada quando o docker for executado com o subcomandorun, o cliente Docker irá primeiro baixar a imagem, depois executar um container usando esta imagem.

      Para ver as imagens que foram baixadas para seu computador, digite:

      A saída deve ser semelhante à seguinte:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE ubuntu latest 113a43faa138 4 weeks ago 81.2MB hello-world latest e38bc07ac18e 2 months ago 1.85kB

      Como você verá posteriormente nesse tutorial, as imagens que você usa para executar containers podem ser modificadas e utilizadas para gerar novas imagens, que podem ser enviadas (fazer um push, em termos técnicos) para o Docker Hub ou outros registros Docker.

      Vamos dar uma olhada em como executar containers em mais detalhes.

      Passo 5 — Executando um Container Docker

      O container hello-world que você executou no passo anterior é um exemplo de um container que executa e sai depois da emissão de uma mensagem de teste. Os containers podem ser muito mais úteis do que isso e podem ser interativos. Afinal, eles são semelhantes às máquinas virtuais, apenas mais fáceis de usar.

      Como um exemplo, vamos executar um container usando a versão mais recente do ubuntu. A combinação das chaves -i e -t dá a você um acesso a um shell interativo dentro do container:

      Seu prompt de comando deve mudar para refletir o fato de que você agora está trabalhando dentro do container e deve assumir essa forma:

      Output

      root@d9b100f2f636:/#

      Observe o id do container no prompt de comando. Nesse exemplo, ele é d9b100f2f636. Você precisará do ID do container posteriormente para identificar o container quando quiser removê-lo.

      Agora você pode executar qualquer comando dento do container. Por exemplo, vamos atualizar o banco de dados de pacotes dentro do container. Você não precisa prefixar quaisquer comandos com sudo porque você está operando dentro do container como usuário root:

      A seguir, instale qualquer aplicação dentro dele. Vamos instalar o Node.js:

      Isso instala o Node.js no container a partir do repositório oficial do Ubuntu. Quando a instalação terminar, verifique que o Node.js está instalado:

      Você verá o número da versão exibido em seu terminal:

      Output

      v8.10.0

      Quaisquer alterações feitas no container só se aplicam a esse container.

      Para sair do container, digite exit no prompt.

      A seguir, vamos analisar o gerenciamento dos containers em nosso sistema.

      Passo 6 — Gerenciando Containers Docker

      Depois de usar o Docker por um tempo, você terá muitos containers ativos (em execução) e inativos em seu computador. Para ver os containers ativos, utilize:

      Você verá uma saída similar à seguinte:

      Output

      CONTAINER ID IMAGE COMMAND CREATED

      Neste tutorial, você iniciou dois containers; um a partir da imagem hello-world e outro a partir da imagem ubuntu. Ambos os containers não estão mais executando, mas eles ainda existem em seu sistema.

      Para ver todos os containers — ativos e inativos, execute docker ps com a chave -a:

      Você verá uma saída semelhante a esta:

      d9b100f2f636        ubuntu              "/bin/bash"         About an hour ago   Exited (0) 8 minutes ago                           sharp_volhard
      01c950718166        hello-world         "/hello"            About an hour ago   Exited (0) About an hour ago                       festive_williams
      

      Para ver o último container que você criou, passe a ele a chave -l:

      • CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
      • d9b100f2f636 ubuntu "/bin/bash" About an hour ago Exited (0) 10 minutes ago sharp_volhard

      Para iniciar um container parado, use docker start, seguido pelo ID do container ou o nome dele. Vamos iniciar o container baseado no Ubuntu com o ID d9b100f2f636:

      • docker start d9b100f2f636

      O container vai iniciar, e você pode usar docker ps para ver seu status:

      CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
      d9b100f2f636        ubuntu              "/bin/bash"         About an hour ago   Up 8 seconds                            sharp_volhard
      

      Para parar um container em execução, use docker stop, seguido do nome ou ID do container. Dessa vez, vamos usar o nome que o registro Docker atribuiu ao container, que é sharp_volhard:

      • docker stop sharp_volhard

      Depois que você decidir que não precisa mais de um container, remova-o com o comando docker rm, novamente usando ou o ID do container ou seu nome. Use o comando docker ps -a para encontrar o ID ou o nome do container associado à imagem hello-world e remova-o.

      • docker rm festive_williams

      Você pode inciar um novo container e dar a ele um nome utilizando a chave --name. Você também pode utilizar a chave --rm para criar um container que se auto remove quando é parado. Veja o comando docker run help para mais informações sobre essas e outras opções.

      Os containers podem ser transformados em imagens que você pode usar para criar novos containers. Vamos ver como isso funciona.

      Passo 7 — Fazendo Commit de Alterações em um Container para uma Imagem Docker

      Quando você inicia uma imagem Docker, você pode criar, modificar e excluir arquivos da mesma forma que você faz em máquinas virtuais. As alterações que você fizer serão aplicadas apenas a esse container. Você pode iniciá-lo ou pará-lo, mas uma vez que você o destrua com o comando docker rm, as mudanças serão perdidas para sempre.

      Esta seção mostra como salvar o estado de um container como uma nova imagem do Docker.

      Depois de instalar o Node.js dentro do container Ubuntu, você tem agora um container executando a partir de uma imagem, mas o container é diferente da imagem que você usou para criá-lo. Mas você pode querer reutilizar esse container Node.js como base para novas imagens posteriormente.

      Então, faça o commit das alterações em uma nova instância de imagem do Docker usando o seguinte comando.

      • docker commit -m "O que você fez na imagem" -a "Nome do Autor" container_id repositório/novo_nome_da_imagem

      A chave -m é para a mensagem de commit que ajuda você e outras pessoas saberem quais mudanças você fez, enquanto -a é usado para especificar o autor. O container_id é aquele que você observou anteriormente no tutorial quando iniciou a sessão interativa do Docker. A menos que você tenha criado repositórios adicionais no Docker Hub, o repositório geralmente é seu nome de usuário do Docker Hub.

      Por exemplo, para o usuário sammy, com ID do container d9b100f2f636, o comando seria:

      • docker commit -m "added Node.js" -a "sammy" d9b100f2f636 sammy/ubuntu-nodejs

      Quando você faz o commit de uma imagem, a nova imagem é salva localmente em seu computador. Posteriormente, nesse tutorial, você aprenderá a enviar uma imagem para um registro do Docker, como o Docker Hub, para que outras pessoas possam acessá-la.

      Ao listar as imagens do Docker novamente será mostrado a nova imagem, bem como a antiga da qual foi derivada:

      docker images
      

      Você verá uma saída como essa:

      Output
      REPOSITORY               TAG                 IMAGE ID            CREATED             SIZE
      sammy/ubuntu-nodejs   latest              7c1f35226ca6        7 seconds ago       179MB
      ubuntu                   latest              113a43faa138        4 weeks ago         81.2MB
      hello-world              latest              e38bc07ac18e        2 months ago        1.85kB
      

      Neste exemplo, ubuntu-nodejs é a nova imagem, a qual foi derivada da imagem existente ubuntu do Docker Hub. A diferença de tamanho reflete as alterações feitas. E neste exemplo, a mudança foi que o NodeJS foi instalado. Então, da próxima vez que você precisar executar um container usando o Ubuntu com o NodeJS pré-instalado, você pode simplesmente usar a nova imagem.

      Você também pode criar imagens a partir de um Dockerfile, que permite automatizar a instalação de software em uma nova imagem. No entanto, isso está fora do escopo deste tutorial.

      Agora vamos compartilhar a nova imagem com outras pessoas para que elas possam criar containers a partir dela.

      Passo 8 — Enviando Imagens Docker para um Repositório Docker

      A próxima etapa lógica após criar uma nova imagem a partir de uma imagem existente é compartilhá-la com alguns poucos amigos selecionados, o mundo inteiro no Docker Hub ou outro registro do Docker ao qual você tem acesso. Para enviar uma imagem para o Docker Hub ou qualquer outro registro Docker, você deve ter uma conta lá.

      Esta seção mostra como enviar uma imagem do Docker para o Docker Hub. Para aprender como criar seu próprio registro privado do Docker, confira How To Set Up a Private Docker Registry on Ubuntu 14.04.

      Para enviar sua imagem, primeiro efetue o login no Docker Hub.

      • docker login -u nome-de-usuário-do-registro-docker

      Você será solicitado a autenticar usando sua senha do Docker Hub. Se você especificou a senha correta, a autenticação deve ser bem-sucedida.

      Note: Se seu nome de usuário do registro do Docker for diferente do nome de usuário local usado para criar a imagem, você terá que marcar sua imagem com o nome de usuário do registro. Para o exemplo dado na última etapa, você digitaria:

      • docker tag sammy/ubuntu-nodejs nome-de-usuário-do-registro-docker/ubuntu-nodejs

      Então você pode enviar sua própria imagem usando:

      • docker push nome-de-usuário-do-registro-docker/nome-da-imagem-docker

      Para enviar a imagem ubuntu-nodejs para o repositório sammy, o comando seria:

      • docker push sammy/ubuntu-nodejs

      O processo pode levar algum tempo para ser concluído enquanto ele carrega as imagens, mas quando concluído, a saída será algo assim:

      Output

      The push refers to a repository [docker.io/sammy/ubuntu-nodejs] e3fbbfb44187: Pushed 5f70bf18a086: Pushed a3b5c80a4eba: Pushed 7f18b442972b: Pushed 3ce512daaf78: Pushed 7aae4540b42d: Pushed ...

      Após o envio de uma imagem para um registro, ela deve ser listada no dashboard de sua conta, como aquele mostrado na imagem abaixo:

      Se uma tentativa de envio resultar em um erro desse tipo, provavelmente você não efetuou login:

      Output

      The push refers to a repository [docker.io/sammy/ubuntu-nodejs] e3fbbfb44187: Preparing 5f70bf18a086: Preparing a3b5c80a4eba: Preparing 7f18b442972b: Preparing 3ce512daaf78: Preparing 7aae4540b42d: Waiting unauthorized: authentication required

      Faça login com docker login e repita a tentativa de envio. Em seguida, verifique que ela existe na sua página de repositório do Docker Hub.

      Agora voce pode usar docker pull sammy/ubuntu-nodejs para para puxar a imagem para uma nova máquina e usá-la para executar um novo container.

      Conclusão

      Neste tutorial, você instalou o Docker, trabalhou com imagens e containers e enviou uma imagem modificada para o Docker Hub. Agora que você conhece o básico, explore os outros tutoriais do Docker na comunidade da DigitalOcean.

      Por Brian Hogan



      Source link

      Como Instalar e Usar o Composer no Ubuntu 18.04


      Uma versão anterior desse tutorial foi escrito por Brennen Bearnes.

      Introdução

      O Composer é uma ferramenta popular de gerenciamento de dependências para o PHP, criado principalmente para facilitar a instalação e atualização para dependências de projeto. Ele verificará de quais outros pacotes um projeto específico depende e os instalará para você, usando as versões apropriadas de acordo com os requisitos do projeto.

      Neste tutorial, você instalará e começará a usar o Composer em um sistema Ubuntu 18.04.

      Pré-requisitos

      Para completar este tutorial, você vai precisar de:

      Passo 1 — Instalando as Dependências

      Antes de você baixar e instalar o Composer, você deve certificar-se de que seu servidor tenha todas as dependências instaladas.

      Primeiro, atualize o cache do gerenciador de pacotes executando:

      Agora, vamos instalar as dependências. Precisaremos do curl para que possamos baixar o Composer e o phi-cli para instalação e execução dele. O pacote php-mbstring é necessário para fornecer funções para a biblioteca que estaremos utilizando. O git é utilizado pelo Composer para baixar as dependências de projeto, e o unzip para a extração dos pacotes compactados. Tudo pode ser instalado com o seguinte comando:

      • sudo apt install curl php-cli php-mbstring git unzip

      Com os pré-requisitos instalados, podemos instalar o Composer propriamente dito.

      Passo 2 — Baixando e Instalando o Composer

      O Composer fornece um instalador, escrito em PHP. Iremos baixá-lo, verificar que o mesmo não está corrompido, e então utilizá-lo para instalar o Composer.

      Certtifique-se de você está em seu diretório home, em seguida baixe o instalador utilizando o curl:

      • cd ~
      • curl -sS https://getcomposer.org/installer -o composer-setup.php

      A seguir, verifique se o instalador corresponde ao hash SHA-384 para o instalador mais recente encontrado na página Composer Public Keys / Signatures. Copie o hash desta página e armazene-o em uma variável do shell.

      • HASH=544e09ee996cdf60ece3804abc52599c22b1f40f4323403c44d44fdfdd586475ca9813a858088ffbc1f233e9180f061

      Certifique-se de que você substituiu o hash mais recente para o valor destacado.

      Agora, execute o seguinte script PHP para verificar que o script de instalação é seguro para execução:

      • php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

      Você verá a seguinte saída:

      Output

      Installer verified
      

      Se você vir Installer corrupt, então você vai precisar baixar novamente o script de instalação e conferir minuciosamente se você está utilizando o hash correto. Depois, execute o comando para verificar o instalador novamente. Uma vez que você tenha o instalador verificado, você pode continuar.

      Para instalar o composer globalmente, utilize o seguinte comando que irá baixar e instalar o Composer como um comando disponível para todo o sistema chamado composer, dentro de /usr/local/bin:

      • sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

      Você verá a seguinte saída:

      Output

      All settings correct for using Composer Downloading... Composer (version 1.6.5) successfully installed to: /usr/local/bin/composer Use it: php /usr/local/bin/composer

      Para testar a sua instalação, execute:

      E você verá esta saída mostrando a versão e os argumentos do Composer.

      Output

      ______ / ____/___ ____ ___ ____ ____ ________ _____ / / / __ / __ `__ / __ / __ / ___/ _ / ___/ / /___/ /_/ / / / / / / /_/ / /_/ (__ ) __/ / ____/____/_/ /_/ /_/ .___/____/____/___/_/ /_/ Composer version 1.6.5 2018-05-04 11:44:59 Usage: command [options] [arguments] Options: -h, --help Display this help message -q, --quiet Do not output any message -V, --version Display this application version --ansi Force ANSI output --no-ansi Disable ANSI output -n, --no-interaction Do not ask any interactive question --profile Display timing and memory usage information --no-plugins Whether to disable plugins. -d, --working-dir=WORKING-DIR If specified, use the given directory as working directory. -v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug . . .

      Isso verifica que o Composer foi instalado com sucesso em seu sistema e está disponível de maneira global para todos.

      Nota: se você preferir ter executáveis do Composer separados para cada projeto que você hospedar neste servidor, você poderá instalá-lo localmente, em uma base por projeto. Usuários do NPM estarão familiarizados com esta abordagem. Este método é útil também quando seu usuário de sistema não tem permissão para instalar software para todo o sistema.

      Para fazer isto, utilize o comando php composer-setup.php. Isto irá gerar um arquivo composer.phar em seu diretório atual, que pode ser executado com ./composer.pharcomando.

      Agora, vamos dar uma olhada em como utilizar o Composer para gerenciar dependências.

      Passo 3 — Usando o Composer em um Projeto PHP

      Projetos PHP frequentemente dependem de bibliotecas externas, e o gerenciamento dessas dependências e suas versões pode ser complicado. O Composer resolve isso rastreando suas dependências e facilitando a instalação delas por outras pessoas.

      Para usar o Composer no seu projeto, você precisa de um arquivo composer-json. O arquivo composer.json diz ao Composer quais dependências ele precisa baixar para o seu projeto, e para quais versões de cada pacote está permitida a instalação. Isto é extremamente importante para manter o seu projeto consistente e evitar a instalação de versões instáveis que podem causar problemas de compatibilidade com versões anteriores.

      Você não precisa criar este arquivo manualmente - é fácil cometer erros de sintaxe quando você faz isso. O Composer gera automaticamente o arquivo composer.json quando você adiciona uma dependêcia para o seu projeto utilizando o comando require. Você pode adicionar dependências adicionais da mesma forma, sem a necessidade de editar manualmente este arquivo.

      O processo de se utilizar o Composer para instalar um pacote como dependência em um projeto envolve os sequintes passos:

      • Identificar qual tipo de biblioteca a aplicação precisa.

      • Pesquisar uma biblioteca de código aberto adequada em Packagist.org, o repositório de pacotes oficial para o Composer.

      • Escolher o pacote do qual você quer depender.

      • Executar composer require para incluir a dependência no arquivo composer.json e instalar o pacote.

      Vamos tentar isso com uma aplicação de demonstração.

      O objetivo dessa aplicação é transformar uma dada sentença em uma string com URL amigável - um slug. Isso é comumente usado para converter títulos de páginas em caminhos de URL (como a parte final da URL deste tutorial).

      Vamos começar criando o diretório para nosso projeto. Vamos chamá-lo de slugify:

      • cd ~
      • mkdir slugify
      • cd slugify

      Agora é a hora de pesquisar no Packagist.org um pacote que possa nos ajudar a gerar slugs. Se você pesquisar pelo termo "slug" no Packagist, você obterá um resultado semelhante a esse:

      Você verá dois números do lado direito de cada pacote na lista. O número no topo representa quantas vezes o pacote foi instalado, e o número embaixo mostra quantas vezes um pacote recebeu estrelas no GitHub. Você pode reorganizar os resultados da pesquisa com base nesses números (procure os dois ícones no lado direito da barra de pesquisa). De um modo geral, pacotes com mais instalações e mais estrelas tendem a ser mais estáveis, já que muitas pessoas estão usando. Também é importante verificar a descrição do pacote quanto à relevância para garantir que é o que você precisa.

      Precisamos de um conversor siples de string-para-slug. Nos resultados da pesquisa, o pacote cocur/slugify parece ser uma boa escolha, com uma quantidade razoável de instalações e estrelas. (O pacote está um pouco mais abaixo na página do que a imagem mostra.)

      Os pacotes no Packagist tem um nome de vendor e um nome de package ou pacote. Cada pacote tem um identificador único (um namespace) no mesmo formato que o GitHub utiliza para seus repositórios, no formato vendor/package. A biblioteca que queremos instalar utiliza o namespace cocur/slugif. Você precisa do namespace para requerer o pacote em seu projeto.

      Agora que você sabe exatamente quais pacotes você quer instalar, execute composer require para incluí-los como uma dependência e gere também o arquivo composer.json para o projeto:

      • composer require cocur/slugify

      Você verá esta saída enquanto o Composer baixa a dependência:

      Output

      Using version ^3.1 for cocur/slugify ./composer.json has been created Loading composer repositories with package information Updating dependencies (including require-dev) Package operations: 1 install, 0 updates, 0 removals - Installing cocur/slugify (v3.1): Downloading (100%) Writing lock file Generating autoload files

      Como você pode ver pela saída, o Composer decide automaticamente qual versão do pacote utilizar. Se você verificar o diretório do seu projeto agora, ele irá conter dois novos arquivos: composer.json e composer.lock, e um diretório vendor:

      Output

      • total 12
      • -rw-rw-r-- 1 sammy sammy 59 Jul 11 16:40 composer.json
      • -rw-rw-r-- 1 sammy sammy 2934 Jul 11 16:40 composer.lock
      • drwxrwxr-x 4 sammy sammy 4096 Jul 11 16:40 vendor

      O arquivo composer.lock é usado para guardar informações sobre quais versões de cada pacote estão instaladas, e garantir que as mesmas versões sejam usadas se alguém clonar seu projeto e instalar suas dependências. O diretório vendor é onde as dependências do projeto estão localizadas. A pasta vendor não precisa ter o commit realizado no controle de versão - você só precisa incluir os arquivos composer.json e composer.lock.

      Ao instalar um projeto que já contém um arquivo composer.json, execute composer install para fazer o download das dependências do projeto.

      Vamos dar uma olhada rápida nas restrições de versão. Se você verificar o conteúdo do seu arquivo composer.json, verá algo como isto:

      Output

      { "require": { "cocur/slugify": "^3.1" } } sam

      Você deve ter notado o caractere especial ^ antes do número da versão no composer.json. O Composer suporta várias restrições e formatos diferentes para definir a versão do pacote necessária, a fim de fornecer flexibilidade e, ao mesmo tempo, manter seu projeto estável. O operador cirunflexo (^) utilizado pelo arquivo auto-gerado composer.json é o operador recomendado para a máxima interoperabilidade, seguindo o versionamento semântico. Nesse caso, ele define 3.1 como a versão mínima compatível, e permite atualizar para quaisquer versões futuras abaixo da 4.00.

      De modo geral, você não precisará adulterar restrições de versão em seu arquivo composer.json. Contudo, algumas situações podem exigir que você edite manualmente as restrições - por exemplo, quando uma nova versão principal de sua biblioteca obrigatória é lançada e você deseja atualizar, ou quando a biblioteca que você deseja usar não segue o versionamento semântico.

      Aqui estão alguns exemplos para entender melhor como funcionam as restrições de versão do Composer:

      Restrição Significado Versões de Exemplo Permitidas
      ^1.0 >= 1.0 < 2.0 1.0, 1.2.3, 1.9.9
      ^1.1.0 >= 1.1.0 < 2.0 1.1.0, 1.5.6, 1.9.9
      ~1.0 >= 1.0 < 2.0.0 1.0, 1.4.1, 1.9.9
      ~1.0.0 >= 1.0.0 < 1.1 1.0.0, 1.0.4, 1.0.9
      1.2.1 1.2.1 1.2.1
      1.* >= 1.0 < 2.0 1.0.0, 1.4.5, 1.9.9
      1.2.* >= 1.2 < 1.3 1.2.0, 1.2.3, 1.2.9

      Para uma visão mais aprofundada das restrições de versão do Composer, consulte a documentação oficial.

      Em seguida, vamos ver como carregar dependências automaticamente com o Composer.

      Passo 4 — Incluindo o Script Autoload

      Como o próprio PHP não carrega classes automaticamente, o Composer fornece um script de carregamento automático que você pode incluir em seu projeto para obter o carregamento automático de graça. Isso facilita muito o trabalho com suas dependências.

      A única coisa que você precisa fazer é incluir o arquivo vendor/autoload.php em seus scripts PHP antes de qualquer instanciamento de classe. Este arquivo é gerado automaticamente pelo Composer quando você adiciona sua primeira dependência.

      Vamos experimentar isso em nossa aplicação. Crie o arquivo test.php e abra-o em seu editor de textos:

      Adicione o seguinte código que traz o arquivo vendor/autoload.php, carrega a dependência cocur/slugify, e a utiliza para criar um slug:

      test.php

      
      <?php
      require __DIR__ . '/vendor/autoload.php';
      
      use CocurSlugifySlugify;
      
      $slugify = new Slugify();
      
      echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');
      

      Salve o arquivo e saia do editor.

      Agora, execute o script:

      Isso produz a saída hello-world-this-is-a-long-sentence-and-i-need-to-make-a-slug-from-it.

      Dependências precisam de atualizações quando novas versões são lançadas, então vamos ver como lidar com isso.

      Passo 5 — Atualizando as Dependências de Projeto

      Sempre que você quiser atualizar suas dependências de projeto para versões mais recentes, execute o comando update:

      Isso irá verificar as versões mais recentes das bibliotecas necessárias em seu projeto. Se uma versão mais nova for encontrada e for compatível com a restrição de versão definida no arquivo composer.json, o Composer substituirá a versão anterior instalada. O arquivo composer.lock será atualizado para refletir estas mudanças.

      Você também pode atualizar uma ou mais bibliotecas específicas, especificando-as assim:

      • composer update vendor/package vendor2/package2

      Certifique-se de verificar seus arquivos composer.json ecomposer.lock depois de atualizar suas dependências para que outras pessoas possam instalar essas versões mais novas.

      Conclusão

      O Composer é uma ferramenta poderosa que todo desenvolvedor de PHP deve ter em seu cinto de utilidades. Neste tutorial você instalou o Composer e o utilizou em um projeto simples. Agora você sabe como instalar e atualizar dependências.

      Além de fornecer uma maneira fácil e confiável de gerenciar dependências de projetos, ele também estabelece um novo padrão de fato para compartilhar e descobrir pacotes PHP criados pela comunidade.

      Brian Hogan



      Source link

      Como Instalar e Configurar o GitLab no Ubuntu 16.04


      Introdução

      O GitLab CE, ou Community Edition, é uma aplicação open source usada principalmente para hospedar repositórios Git, com recursos adicionais relacionados ao desenvolvimento, como rastreamento de problemas. Ele é projetado para ser hospedado usando a sua própria infraestrutura, e fornece flexibilidade na implantação como um repositório interno para sua equipe de desenvolvimento, publicamente como uma forma de interagir com usuários, ou até mesmo aberto como forma de os colaboradores hospedarem seus próprios projetos.

      O projeto do GitLab torna relativamente simples a configuração de uma instância do GitLab em seu próprio hardware com um mecanismo de fácil instalação. Neste guia vamos cobrir como instalar e configurar o GitLab em um servidor Ubuntu 16.04.

      Pré-Requisitos

      Este tutorial irá assumir que você tem acesso a um novo servidor Ubuntu 16.04. Os requisitos de hardware publicados do GitLab recomendam a utilização de um servidor com:

      Embora você possa substituir algum espaço de swap por RAM, isso não é recomendado. Para este guia assumiremos que você tem os recursos acima, no mínimo.

      Para começar, você vai precisar de um usuário não-root com acesso sudo configurado no servidor. É também uma boa ideia configurar um firewall básico para fornecer uma camada adicional de segurança. Você pode seguir os passos em nosso tutorial Configuração Inicial de servidor com Ubuntu 16.04 para obter essa configuração.

      Quando tiver satisfeito os pré-requisitos acima, continue para iniciar o procedimento de instalação.

      Instalando as Dependências

      Antes que possamos instalar o GitLab propriamente dito, é importante instalar alguns dos softwares que ele aproveita durante a instalação e que ele usa de forma contínua. Felizmente, todos os softwares necessários podem ser facilmente instalados a partir dos repositórios padrão do Ubuntu.

      Já que esta é a nossa primeira vez usando o apt durante esta sessão, podemos atualizar o índice de pacotes local e depois instalar as dependências digitando:

      • sudo apt-get update
      • sudo apt-get install ca-certificates curl openssh-server postfix

      Você provavelmente já terá alguns desses softwares instalados. Para a instalação do postfix, selecione Internet Site quando solicitado. Na próxima tela, entre com o nome de domínio do seu servidor ou seu endereço IP para configurar de que forma o sistema enviará e-mail.

      Instalando o GitLab

      Agora que as dependências estão instaladas, podemos instalar o GitLab. Este é um processo direto que utiliza um script de instalação para configurar seu sistema com os repositórios do GitLab.

      Vá para o diretório /tmp e então baixe o script de instalação:

      • cd /tmp
      • curl -LO https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh

      Fique à vontade para examinar o script baixado para assegurar-se de que você esteja confortável com as ações que ele irá tomar. Você pode encontrar uma versão hospedada do script aqui:.

      Quando estiver satisfeito com a segurança do script, execute o instalador:

      • sudo bash /tmp/script.deb.sh

      Este script irá configurar seu servidor para utilizar os repositórios mantidos pelo GitLab. Isso lhe permite gerenciar o GitLab com as mesmas ferramentas de gerenciamento de pacotes que você usa para seus outros pacotes de sistema. Quando estiver completo, você pode instalar a aplicação real do GitLab com o apt:

      • sudo apt-get install gitlab-ce

      Isto irá instalar os componentes necessários em seu sistema.

      Ajustando as Regras de Firewall

      Antes de configurar o GitLab, você precisará garantir que suas regras de firewall são permissivas o suficiente para permitir o tráfego web. Se você seguiu o guia vinculado nos pré-requisitos, você terá um firewall ufw ativado.

      Veja o status atual do seu firewall ativo digitando:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6)

      Como você pode ver, as regras atuais permitem o tráfego SSH, mas o acesso a outros serviços está restrito. Como o Gitlab é uma aplicação web, devemos permitir acesso HTTP entrante. Se você tiver um nome de domínio associado com o seu servidor GitLab, o GitLab pode também solicitar e ativar um certificado gratuito TLS/SSL a partir do projeto Let's Encrypt para proteger a instalação. Também queremos permitir o acesso HTTPS nesse caso.

      um vez que o protocolo de mapeamento de portas para HTTP e HTTPS está disponível no arquivo /etc/services, podemos permitir tais tráfegos pelo nome. Se você ainda não ativou o tráfego do OpenSSH, permita também esse tráfego agora:

      • sudo ufw allow http
      • sudo ufw allow https
      • sudo ufw allow OpenSSH

      Se você verificar com o comando ufw status novamente, você deverá ver o acesso configurado para no mínimo esses dois serviços:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80 ALLOW Anywhere 443 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80 (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6)

      A saída acima indica que a interface web do GitLab estará acessível assim que configurarmos a aplicação.

      Editando o Arquivo de Configuração do GitLab

      Antes de você poder usar a aplicação, você precisa atualizar um arquivo de configuração e executar um comando de reconfiguração. Primeiro, abra o arquivo de configuração do GitLab:

      • sudo nano /etc/gitlab/gitlab.rb

      Perto do topo está a linha de configuração external_url. Atualize-a para corresponder ao seu próprio domínio ou endereço IP. Se você tem um domínio, altere o http para https para que o GitLab redirecione automaticamente os usuários para o site protegido pelo certificado do Let´s Encrypt que estaremos solicitando.

      /etc/gitlab/gitlab.rb

      
      # If your GitLab server does not have a domain name, you will need to use an IP
      # address instead of a domain and keep the protocol as `http`.
      external_url 'https://seu_dominio'
      

      Em seguida, se seu servidor GitLab tem um nome de domínio, pesquise o arquivo pela configuração letsencrypt['enable']. Descomente a linha e defina-a para true. Isso dirá ao GitLab para solicitar um certificado Let´s Encrypt para seu domínio GitLab e configurar a aplicação para servir o tráfego com ele.

      Abaixo disso, procure a configuração letsencrypt['contact_emails']. Esta configuração define uma lista de endereços de e-mail que o projeto Let´s Encrypt pode utilizar para lhe contatar se houver problemas com seu domínio. É uma boa idéia descomentar e preencher isso também para que você saiba de quaisquer problemas:

      /etc/gitlab/gitlab.rb

      
      letsencrypt['enable'] = true
      letsencrypt['contact_emails'] = ['sammy@seu_domínio.com']
      

      Salve e feche o arquivo. Agora, execute o seguinte comando para reconfigurar o GitLab:

      • sudo gitlab-ctl reconfigure

      Isso irá inicializar o GitLab utilizando as informações que ele pode encontrar sobre seu servidor. Esse é um processo completamente automatizado, portanto você não vai ter que responder a nenhuma solicitação. Se você ativou a integração com o Let´s Encrypt, um certificado deve ser configurado para o seu domínio.

      Realizando a Configuração Inicial Através da Interface web

      Agora que o GitLab está executando e o acesso está permitido, podemos realizar algumas configurações iniciais da aplicação através da interface web.

      Efetuando o Login pela Primeira Vez

      Visite o nome de domínio do seu servidor GitLab em seu navegador:

      http://domínio_gitlab_ou_IP
      

      Se você ativou o Let's Encrypt e usou https em seu external_url, você deve ser redirecionado para uma conexão HTTPS segura.

      Em sua primeira visita, você deve ver uma solicitação inicial para definir uma senha para a conta administrativa:

      Na solicitação inicial de senha, forneça e confirme uma senha segura para a conta administrativa. Clique no botão Change your password quando tiver terminado.

      Você será redirecionado à página convencional de login do GitLab:

      Aqui, você pode efetuar o login com a senha que você acabou de definir. As credenciais são:

      Entre com esses valores nos campos para os usuários existentes e clique no botão Sign in. Você será autenticado no aplicativo e levado a uma página de entrada que solicitará que você comece a adicionar projetos:

      Agora você pode fazer algumas mudanças simples para configurar o GitLab da maneira que você quiser.

      Ajustando suas Configurações de Perfil

      Uma das primeiras coisas que você deve fazer após uma nova instalação é colocar o seu perfil na melhor forma. O GitLab seleciona alguns padrões razoáveis, mas estes geralmente não são apropriados quando você começa a usar o software.

      Para fazer as modificações necessárias, clique no ícone do usuário no canto superior direito da interface. No menu suspenso exibido, selecione Settings:

      Você será levado para a seção de perfil ou Profile nas suas configurações:

      Ajuste Name e Email trocando "Administrator" e "admin@example.com" para algo mais adequado. O nome que você selecionou será mostrado para os outros usuários, equanto o e-mail será utilizado para detecção padrão do avatar, notificações, ações no Git através da interface, etc.

      Clique no botão Update Profile setting na parte inferior quando terminar:

      Um e-mail de confirmação será enviado ao endereço que você forneceu.
      Siga as instruções no e-mail para confirmar sua conta para que você possa começar a utilização do GitLab.

      Alterando o Nome da Sua Conta

      A seguir, clique no item Account na barra de menu à esquerda:

      Aqui, você pode encontrar seu token de API privada ou configurar a autenticação de dois fatores. Contudo, a funcionalidade a qual estamos interessados no momento é a seção Change username.

      Por padrão, à primeira conta administrativa é dado o nome root. Como esse é um nome conhecido de conta, é mais seguro alterar esse nome para um diferente. Você ainda terá privilégios administrativos; a única coisa que irá mudar é o nome:

      Clique no botão Update username para fazer a alteração:

      Na próxima vez que você fizer o login no GitLab, lembre-se de utilizar seu novo nome de usuário.

      Adicionando uma Chave SSH à sua Conta

      Em muitos casos, você irá querer usar chaves SSH com Git para interagir com seus projetos GitLab. Para fazer isso, você precisa adicionar sua chave pública à sua conta do GitLab.

      Se você já tem um par de chaves SSH criado em seu computador local, você geralmente pode ver a chave pública digitando:

      Você deverá ver um grande pedaço de texto, como este:

      Output

      ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDMuyMtMl6aWwqBCvQx7YXvZd7bCFVDsyln3yh5/8Pu23LW88VXfJgsBvhZZ9W0rPBGYyzE/TDzwwITvVQcKrwQrvQlYxTVbqZQDlmsC41HnwDfGFXg+QouZemQ2YgMeHfBzy+w26/gg480nC2PPNd0OG79+e7gFVrTL79JA/MyePBugvYqOAbl30h7M1a7EHP3IV5DQUQg4YUq49v4d3AvM0aia4EUowJs0P/j83nsZt8yiE2JEYR03kDgT/qziPK7LnVFqpFDSPC3MR3b8B354E9Af4C/JHgvglv2tsxOyvKupyZonbyr68CqSorO2rAwY/jWFEiArIaVuDiR9YM5 sammy@mydesktop

      Copie esse texto e volte para a página de configurações do perfil na interface web do gitLab.

      Se, em vez disso, você receber uma mensagem parecida como isto, você ainda não tem um par SSH configurado em sua máquina:

      Output

      cat: /home/sammy/.ssh/id_rsa.pub: No such file or directory

      Se for o caso, você pode criar um par de chaves SSH digitando:

      Aceite os padrões e, opcionalmente, forneça uma senha para proteger a chave localmente:

      Output

      Generating public/private rsa key pair. Enter file in which to save the key (/home/sammy/.ssh/id_rsa): Enter passphrase (empty for no passphrase): Enter same passphrase again: Your identification has been saved in /home/sammy/.ssh/id_rsa. Your public key has been saved in /home/sammy/.ssh/id_rsa.pub. The key fingerprint is: SHA256:I8v5/M5xOicZRZq/XRcSBNxTQV2BZszjlWaIHi5chc0 sammy@gitlab.docsthat.work The key's randomart image is: +---[RSA 2048]----+ | ..%o==B| | *.E =.| | . ++= B | | ooo.o . | | . S .o . .| | . + .. . o| | + .o.o ..| | o .++o . | | oo=+ | +----[SHA256]-----+

      Depois de ter isso, você pode exibir sua chave pública como acima, digitando:

      Output

      ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDMuyMtMl6aWwqBCvQx7YXvZd7bCFVDsyln3yh5/8Pu23LW88VXfJgsBvhZZ9W0rPBGYyzE/TDzwwITvVQcKrwQrvQlYxTVbqZQDlmsC41HnwDfGFXg+QouZemQ2YgMeHfBzy+w26/gg480nC2PPNd0OG79+e7gFVrTL79JA/MyePBugvYqOAbl30h7M1a7EHP3IV5DQUQg4YUq49v4d3AvM0aia4EUowJs0P/j83nsZt8yiE2JEYR03kDgT/qziPK7LnVFqpFDSPC3MR3b8B354E9Af4C/JHgvglv2tsxOyvKupyZonbyr68CqSorO2rAwY/jWFEiArIaVuDiR9YM5 sammy@mydesktop

      Copie o bloco de texto exibido e volte para as configurações do perfil na interface web do GitLab.

      Clique no item SSH keys no menu à esquerda:

      No espaço fornecido cole a chave pública que você copiou da sua máquina local. Dê a ela um título descritivo, e clique no botão Add key:

      Agora você deve conseguir gerenciar seus projetos e repositórios do GitLab a partir de sua máquina local sem ter que fornecer suas credenciais de conta do GitLab.

      Restringindo ou Desabilitando Inscrições Públicas (Opcional)

      Você deve ter notado que é possível que alguém se inscreva para uma conta quando visitar a página de destino da sua instância do GitLab. Isso pode ser o que você deseja se estiver hospedando um projeto público. No entanto, muitas vezes, configurações mais restritivas são desejáveis.

      Para começar, vá até a área administrativa clicando no ícone de chave inglesa na barra de menu principal na parte superior da página:

      Na página seguinte, você pode ver uma visão geral da sua instância do GitLab como um todo. Para ajustar as configurações, clique no item Settings na parte inferior do menu à esquerda.

      Você será levado para as configurações globais da sua instância do GitLab. Aqui, você pode ajustar várias configurações que afetam se novos usuários podem se inscrever e qual será o nível de acesso deles.

      Desabilitando Inscrições

      Se você deseja desabilitar completamente as inscrições (você ainda pode criar manualmente as contas para novos usuários), desça até a seção Sign-up Restrictions.

      Desmarque a caixa de seleção Sign-up enabled:

      Role para baixo até o final e clique no botão Save:

      A seção de inscrição agora deve estar removida da página inicial do GitLab.

      Restringindo Inscrições Por Domínio

      Se você estiver usando o GitLab como parte de uma organização que fornece endereços de e-mail associados a um domínio, poderá restringir as inscrições por domínio em vez de desativá-las completamente.

      Na seção Sign-up Restrictions, primeiro selecione a caixa Send confirmation email on sign-up permitindo somente que os usuários façam login depois de confirmarem seus e-mails.

      Em seguida, adicione o seu domínio ou domínios à caixa Whitelisted domains for sign-ups, uma por linha. Você pode utilizar o asterisco "*" para especificar domínios curinga.

      Role para baixo até o final e clique no botão Salvar:

      A seção de inscrição agora deve estar removida da página inicial do GitLab.

      Restringindo a Criação de Projetos

      Por padrão, novos usuários podem criar até 10 projetos. Se você deseja permitir que novos usuários externos tenham visibilidade e participação, mas quer restringir seus acessos ao criar novos projetos, você pode fazer isto na seção Account and Limit Settings.

      Lá dentro, você pode alterar o limite padrão de projetos em Default projects limit para 0 para desativar completamente a criação de projetos por novos usuários.

      Novos usuários ainda podem ser adicionados a projetos manualmente e terão acesso a projetos internos ou públicos criados por outros usuários.

      Role para baixo até o final e clique no botão Salvar:

      Agora, novos usuários poderão criar contas, mas não poderão criar projetos.

      Criando um Cron Job para Renovar Automaticamente os Certificados Let's Encrypt

      Por padrão, os certificados Let's Encrypt são válidos por 90 dias. Se você ativou o Let's Encrypt para o seu domínio do GitLab anteriormente, você precisará garantir que seus certificados sejam renovados regularmente para evitar interrupções no serviço. O GitLab fornece o comando gitlab-ctl renew-le-certs para solicitar novos certificados quando seus ativos atuais se aproximarem da expiração.

      Para automatizar este processo, podemos criar um cron job para executar automaticamente este comando regularmente. O comando somente irá renovar o certificado quando ele estiver perto da expiração, para que possamos executá-lo com segurança regularmente

      Para começar, crie e abra um arquivo em /etc/cron.daily/gitlab-le em seu editor de textos:

      • sudo nano /etc/cron.daily/gitlab-le

      Dentro dele, cole o seguinte script:

      /etc/cron.daily/gitlab-le

      
      #!/bin/bash
      
      set -e
      
      /usr/bin/gitlab-ctl renew-le-certs > /dev/null
      

      Salve e feche o arquivo quando tiver terminado.

      Marque o arquivo como executável digitando:

      • sudo chmod +x /etc/cron.daily/gitlab-le

      Agora, o GitLab deve verificar automaticamente todos os dias se seu certificado Let's Encrypt precisa ser renovado. Em caso afirmativo, o comando renovará o certificado automaticamente.

      Conclusão

      Agora você deve ter uma instância do GitLab em funcionamento hospedada em seu próprio servidor. Você pode começar a importar ou criar novos projetos e configurar o nível apropriado de acesso para sua equipe. O GitLab está regularmente adicionando recursos e atualizando sua plataforma, por isso confira a página inicial do projeto para se manter atualizado sobre quaisquer melhorias ou avisos importantes.

      Por Justin Ellingwood



      Source link