One place for hosting & domains

      Instalar

      Como Instalar o Servidor Web Apache no CentOS 7


      Introdução

      O servidor HTTP Apache é o servidor web mais utilizado no mundo. Ele fornece muitos recursos poderosos incluindo módulos dinamicamente carregáveis, suporte robusto a mídia, e integração extensiva com outros softwares populares.

      Neste guia, você instalará um servidor web Apache com virtual hosts em seu servidor CentOS 7.

      Pré-requisitos

      Você precisará do seguinte para concluir este guia:

      Passo 1 — Instalando o Apache

      O Apache está disponível nos repositórios de software padrão do CentOS, o que significa que você pode instalá-lo com o gerenciador de pacotes yum.

      Agindo como o usuário não-root, com privilégios sudo configurado nos pré-requisitos, atualize o índice de pacotes local httpd do Apache para refletir as alterações mais recentes do upstream:

      Depois que os pacotes forem atualizados, instale o pacote Apache:

      Após confirmar a instalação, o yum instalará o Apache e todas as dependências necessárias. Quando a instalação estiver concluída, você estará pronto para iniciar o serviço.

      Passo 2 — Verificando seu Servidor Web

      O Apache não inicia automaticamente no CentOS depois que a instalação é concluída. Você precisará iniciar o processo do Apache manualmente:

      • sudo systemctl start httpd

      Verifique se o serviço está sendo executado com o seguinte comando:

      • sudo systemctl status httpd

      Você verá um status active quando o serviço estiver em execução:

      Output

      Redirecting to /bin/systemctl status httpd.service ● httpd.service - The Apache HTTP Server Loaded: loaded (/usr/lib/systemd/system/httpd.service; enabled; vendor preset: disabled) Active: active (running) since Wed 2019-02-20 01:29:08 UTC; 5s ago Docs: man:httpd(8) man:apachectl(8) Main PID: 1290 (httpd) Status: "Processing requests..." CGroup: /system.slice/httpd.service ├─1290 /usr/sbin/httpd -DFOREGROUND ├─1291 /usr/sbin/httpd -DFOREGROUND ├─1292 /usr/sbin/httpd -DFOREGROUND ├─1293 /usr/sbin/httpd -DFOREGROUND ├─1294 /usr/sbin/httpd -DFOREGROUND └─1295 /usr/sbin/httpd -DFOREGROUND ...

      Como você pode ver nesta saída, o serviço parece ter sido iniciado com sucesso. No entanto, a melhor maneira de testar isso é solicitar uma página do Apache.

      Você pode acessar a página inicial padrão do Apache para confirmar que o software está sendo executado corretamente através do seu endereço IP. Se você não souber o endereço IP do seu servidor, poderá obtê-lo de algumas maneiras diferentes a partir da linha de comando.

      Digite isto no prompt de comando do seu servidor:

      Esse comando exibirá todos os endereços de rede do host, assim você receberá um retorno com alguns endereços IP separados por espaços. Você pode experimentar cada um em seu navegador para ver se eles funcionam.

      Alternativamente, você pode usar o curl para solicitar seu IP através do icanhazip.com, que lhe dará seu endereço IPv4 público como visto de outro local na internet:

      Quando você tiver o endereço IP do seu servidor, insira-o na barra de endereços do seu navegador:

      http://ip_do_seu_servidor
      

      Você verá a página padrão do Apache do CentOS 7:

      Default Apache page for CentOS 7

      Esta página indica que o Apache está funcionando corretamente. Ela também inclui algumas informações básicas sobre arquivos importantes do Apache e sobre localizações de diretórios. Agora que o serviço está instalado e em execução, você pode usar diferentes comandos systemctl para gerenciar o serviço.

      Passo 3 — Gerenciando o Processo do Apache

      Agora que você tem seu servidor web funcionando, vamos passar por alguns comandos básicos de gerenciamento.

      Para parar seu servidor web, digite:

      • sudo systemctl stop httpd

      Para iniciar o servidor web quando ele estiver parado, digite:

      • sudo systemctl start httpd

      Para parar e iniciar o serviço novamente, digite:

      • sudo systemctl restart httpd

      Se você estiver simplesmente fazendo alterações de configuração, o Apache pode muita vezes recarregar sem perder conexões. Para fazer isso, use este comando:

      • sudo systemctl reload httpd

      Por padrão, o Apache é configurado para iniciar automaticamente quando o servidor é inicializado. Se isso não é o que você deseja, desabilite esse comportamento digitando:

      • sudo systemctl disable httpd

      Para reativar o serviço para iniciar na inicialização, digite:

      • sudo systemctl enable httpd

      O Apache agora será iniciado automaticamente quando o servidor inicializar novamente.

      A configuração padrão do Apache permitirá que seu servidor hospede um único site. Se você planeja hospedar vários domínios em seu servidor, precisará configurar virtual hosts em seu servidor Apache.

      Passo 4 — Configurando Virtual Hosts (Recomendado)

      Ao utilizar o servidor web Apache, você pode usar virtual hosts (similares aos blocos do servidor no Nginx) para encapsular detalhes de configuração e hospedar mais de um domínio a partir de um único servidor. Neste passo você irá configurar um domínio chamado example.com, mas você deve substituí-lo por seu próprio nome de domínio. Para aprender mais sobre a configuração de um nome de domínio com a DigitalOcean, veja nossa Introdução ao DNS da DigitalOcean.

      O Apache no CentOS 7 tem um bloco de servidor ativado por padrão que é configurado para servir documentos a partir do diretório /var/www/html. Apesar disso funcionar bem para um único site, pode ficar difícil se você estiver hospedando vários sites. Em vez de modificar /var/www/html, você irá criar uma estrutura de diretórios dentro de /var/www para o site example.com, deixando /var/www/html no lugar como o diretório padrão a ser servido se uma requisição de cliente não corresponder a nenhum outro site.

      Crie o diretório html para example.com como segue, usando a flag -p para criar qualquer diretório pai que for necessário:

      • sudo mkdir -p /var/www/example.com/html

      Crie um diretório adicional para armazenar arquivos de log para o site:

      • sudo mkdir -p /var/www/example.com/log

      Em seguida, atribua a propriedade do diretório html com a variável de ambiente $USER:

      • sudo chown -R $USER:$USER /var/www/example.com/html

      Certifique-se de que seu web root ou pasta raiz para web tenha o conjunto de permissões padrão:

      • sudo chmod -R 755 /var/www

      Em seguida, crie uma página de exemplo index.html usando o vi ou seu editor favorito:

      • sudo vi /var/www/example.com/html/index.html

      Pressione i para alternar para o modo INSERT e adicione o seguinte exemplo de HTML ao arquivo:

      /var/www/example.com/html/index.html

      <html>
        <head>
          <title>Welcome to Example.com!</title>
        </head>
        <body>
          <h1>Success! The example.com virtual host is working!</h1>
        </body>
      </html>
      

      Salve e feche o arquivo pressionando ESC, digitando :wq e pressionando ENTER.

      Com o diretório do seu site e o arquivo de index de exemplo no lugar, você está quase pronto para criar os arquivos do virtual host. Os arquivos do virtual host especificam a configuração de seus sites independentes e informam ao servidor Apache como responder a várias solicitações de domínio.

      Antes de criar seus virtual hosts, você precisará criar um diretório sites-available para armazená-los. Você também criará o diretório sites-enabled que informa ao Apache que um virtual host está pronto para servir aos visitantes. O diretório sites-enabled conterá links simbólicos para os virtual hosts que queremos publicar. Crie ambos os diretórios com o seguinte comando:

      • sudo mkdir /etc/httpd/sites-available /etc/httpd/sites-enabled

      Em seguida, você dirá ao Apache para procurar por virtual hosts no diretório sites-enabled. Para fazer isso, edite o arquivo de configuração principal do Apache e adicione uma linha declarando um diretório opcional para arquivos de configuração adicionais:

      • sudo vi /etc/httpd/conf/httpd.conf

      Adicione esta linha ao final do arquivo:

      IncludeOptional sites-enabled/*.conf
      

      Salve e feche o arquivo quando terminar de adicionar essa linha. Agora que você tem seus diretórios de virtual host no lugar, você criará seu arquivo de virtual host.

      Comece criando um novo arquivo no diretório sites-available:

      • sudo vi /etc/httpd/sites-available/example.com.conf

      Adicione o seguinte bloco de configuração e altere o domínio example.com para o seu nome de domínio:

      /etc/httpd/sites-available/example.com.conf

      <VirtualHost *:80>
          ServerName www.example.com
          ServerAlias example.com
          DocumentRoot /var/www/example.com/html
          ErrorLog /var/www/example.com/log/error.log
          CustomLog /var/www/example.com/log/requests.log combined
      </VirtualHost>
      

      Isso dirá ao Apache onde encontrar diretamente a raiz que contém os documentos web publicamente acessíveis. Ele também informa ao Apache onde armazenar logs de erros e de solicitações para esse site específico.

      Salve e feche o arquivo quando terminar.

      Agora que você criou os arquivos do virtual host, você os habilitará para que o Apache saiba como servi-los aos visitantes. Para fazer isso, crie um link simbólico para cada virtual host no diretório sites-enabled:

      • sudo ln -s /etc/httpd/sites-available/example.com.conf /etc/httpd/sites-enabled/example.com.conf

      Seu virtual host agora está configurado e pronto para servir conteúdo. Antes de reiniciar o serviço Apache, vamos garantir que o SELinux tenha as políticas corretas em vigor para seus virtual hosts.

      Passo 5 — Ajustando Permissões do SELinux para Virtual Hosts (Recomendado)

      O SELinux está configurado para funcionar com a configuração padrão do Apache. Como você configurou um diretório de log personalizado no arquivo de configuração de virtual hosts, você receberá um erro se tentar iniciar o serviço Apache. Para resolver isso, você precisa atualizar as políticas do SELinux para permitir que o Apache grave nos arquivos necessários. O SELinux traz maior segurança ao seu ambiente CentOS 7, portanto, não é recomendado desativar completamente o módulo do kernel.

      Existem diferentes maneiras de definir políticas com base nas necessidades do seu ambiente, pois o SELinux permite que você personalize seu nível de segurança. Esta etapa abordará dois métodos de ajuste das políticas do Apache: universalmente e em um diretório específico. Ajustar políticas em diretórios é mais seguro e, portanto, é a abordagem recomendada.

      Ajustando Políticas do Apache Universalmente

      Definir a política do Apache universalmente dirá ao SELinux para tratar todos os processos do Apache de forma idêntica usando o booleano httpd_unified. Embora essa abordagem seja mais conveniente, ela não fornecerá o mesmo nível de controle que uma abordagem centrada em uma diretiva de arquivo ou diretório.

      Execute o seguinte comando para definir uma política universal para o Apache:

      • sudo setsebool -P httpd_unified 1

      O comando setsebool altera os valores booleanos do SELinux. A flag -P atualizará o valor de tempo de inicialização, fazendo com que essa mudança persista durante as reinicializações. httpd_unified é o booleano que irá dizer ao SELinux para tratar todos os processos do Apache como do mesmo tipo, então você habilitou-o com um valor de 1.

      Ajustando as Políticas do Apache em um Diretório

      Configurar individualmente as permissões do SELinux para o diretório /var/www/example.com/log lhe dará mais controle sobre suas políticas do Apache, mas também pode exigir mais manutenção. Como essa opção não está definindo políticas universalmente, você precisará definir manualmente o tipo de contexto para todos os novos diretórios de log especificados em suas configurações de virtual host.

      Primeiro, verifique o tipo de contexto que o SELinux deu ao diretório /var/www/example.com/log:

      • sudo ls -dZ /var/www/example.com/log/

      Este comando lista e imprime o contexto do SELinux do diretório. Você verá uma saída semelhante à seguinte:

      Output

      drwxr-xr-x. root root unconfined_u:object_r:httpd_sys_content_t:s0 /var/www/example.com/log/

      O contexto atual é httpd_sys_content_t, que informa ao SELinux que o processo do Apache só pode ler arquivos criados neste diretório. Neste tutorial, você irá alterar o tipo de contexto do diretório /var/www/example.com/log para httpd_log_t. Esse tipo permitirá ao Apache gerar e agregar arquivos de log da aplicação web:

      • sudo semanage fcontext -a -t httpd_log_t "/var/www/example.com/log(/.*)?"

      Em seguida, use o comando restorecon para aplicar essas mudanças e fazer com que elas persistam durante as reinicializações:

      • sudo restorecon -R -v /var/www/example.com/log

      A flag -R executa este comando recursivamente, o que significa que ele atualizará quaisquer arquivos existentes para usar o novo contexto. A flag -v imprimirá as mudanças de contexto feitas pelo comando. Você verá a seguinte saída confirmando as alterações:

      Output

      restorecon reset /var/www/example.com/log context unconfined_u:object_r:httpd_sys_content_t:s0->unconfined_u:object_r:httpd_log_t:s0

      Você pode listar os contextos mais uma vez para ver as alterações:

      • sudo ls -dZ /var/www/example.com/log/

      A saída reflete o tipo de contexto atualizado:

      Output

      drwxr-xr-x. root root unconfined_u:object_r:httpd_log_t:s0 /var/www/example.com/log

      Agora que o diretório /var/www/example.com/log está usando o tipo httpd_log_t, você está pronto para testar sua configuração de virtual host.

      Passo 6 — Testando o Virtual Host (Recomendado)

      Uma vez que o contexto do SELinux tenha sido atualizado com quaisquer dos métodos, o Apache poderá gravar no diretório /var/www/example.com/log. Agora você pode reiniciar o serviço Apache com sucesso:

      • sudo systemctl restart httpd

      Liste o conteúdo do diretório /var/www/example.com/log para ver se o Apache criou os arquivos de log:

      • ls -lZ /var/www/example.com/log

      Você verá que o Apache foi capaz de criar os arquivos error.log e requests.log especificados na configuração do virtual host:

      Output

      -rw-r--r--. 1 root root 0 Feb 26 22:54 error.log -rw-r--r--. 1 root root 0 Feb 26 22:54 requests.log

      Agora que você tem seu virtual host configurado e as permissões do SELinux atualizadas, o Apache agora servirá seu nome de domínio. Você pode testar isso navegando até http://example.com, onde você deve ver algo assim:

      Success! The example.com virtual host is working!

      Isso confirma que seu virtual host foi configurado e está servindo o conteúdo com êxito. Repita os Passos 4 e 5 para criar novos virtual hosts com permissões do SELinux para domínios adicionais.

      Conclusão

      Neste tutorial, você instalou e gerenciou o servidor web Apache. Agora que você tem seu servidor web instalado, você tem muitas opções para o tipo de conteúdo que você pode servir e as tecnologias que você pode usar para criar uma experiência mais rica.

      Se você quiser criar uma pilha ou stack de aplicação mais completa, consulte este artigo sobre como configurar uma pilha LAMP no CentOS 7.



      Source link

      Como Instalar o Git no CentOS 7


      Introdução

      O controle de versão tornou-se uma ferramenta indispensável no desenvolvimento de software moderno. Os sistemas de controle de versão permitem que você mantenha o controle do seu software no nível do código-fonte. Você pode acompanhar as alterações, reverter para os estágios anteriores e fazer a ramificação ou branching do código base para criar versões alternativas de arquivos e diretórios.

      Um dos sistemas de controle de versão mais populares é o git. Muitos projetos mantêm seus arquivos em um repositório Git, e sites como o GitHub e o Bitbucket tornaram o compartilhamento e a contribuição para o código com o Git mais fácil do que nunca.

      Neste guia, demonstraremos como instalar o Git em um servidor do CentOS 7. Vamos abordar como instalar o software de duas maneiras diferentes, cada uma com seus próprios benefícios, além de como configurar o Git para que você possa começar a colaborar imediatamente.

      Pré-requisitos

      Antes de começar com este guia, há algumas etapas que precisam ser concluídas primeiro.

      Você precisará de um servidor CentOS 7 instalado e configurado com um usuário não-root que tenha privilégios sudo. Se você ainda não fez isso, você pode executar os passos de 1 a 4 no guia de Configuração Inicial do Servidor com CentOS 7 para criar essa conta.

      Depois de ter seu usuário não-root, você pode usá-lo para fazer SSH em seu servidor CentOS e continuar com a instalação do Git.

      Instalar o Git

      As duas formas mais comuns de instalar o Git serão descritas nesta seção. Cada opção tem suas próprias vantagens e desvantagens, e a escolha que você fizer dependerá de suas próprias necessidades. Por exemplo, os usuários que desejam manter atualizações para o software Git provavelmente vão querer usar o yum para instalá-lo, enquanto os usuários que precisam de recursos apresentados por uma versão específica do Git vão querer construir essa versão a partir do código-fonte.

      Opção Um — Instalar o Git com Yum

      A maneira mais fácil de instalar o Git e tê-lo pronto para usar é utilizar os repositórios padrão do CentOS. Este é o método mais rápido, mas a versão do Git que é instalada dessa forma pode ser mais antiga que a versão mais recente disponível. Se você precisa da versão mais recente, considere compilar o git a partir do código-fonte (as etapas para este método podem ser encontradas mais abaixo neste tutorial).

      Use o yum, gerenciador de pacotes nativo do CentOS, para procurar e instalar o pacote git mais recente disponível nos repositórios do CentOS:

      sudo yum install git
      

      Se o comando for concluído sem erro, você terá o git baixado e instalado. Para verificar novamente se ele está funcionando corretamente, tente executar a verificação de versão integrada do Git:

      git --version
      

      Se essa verificação produziu um número de versão do Git, você pode agora passar para Configurando o Git, encontrado mais abaixo neste artigo.

      Opção Dois — Instalar o Git a Partir do Código-fonte

      Se você deseja baixar a versão mais recente do Git disponível, ou simplesmente deseja mais flexibilidade no processo de instalação, o melhor método para você é compilar o software a partir do código-fonte. Isso leva mais tempo, e não será atualizado e mantido através do gerenciador de pacotes yum, mas permitirá que você baixe uma versão mais recente do que a que está disponível através dos repositórios do CentOS, e lhe dará algum controle sobre as opções que você pode incluir.

      Antes de começar, você precisará instalar o software do qual o git depende. Estas dependências estão todas disponíveis nos repositórios padrão do CentOS, junto com as ferramentas que precisamos para construir um binário a partir do código-fonte:

      sudo yum groupinstall "Development Tools"
      sudo yum install gettext-devel openssl-devel perl-CPAN perl-devel zlib-devel
      

      Depois de ter instalado as dependências necessárias, você pode ir em frente e procurar a versão do Git que você deseja, visitando a página de releases do projeto no GitHub.

      Git Releases on GitHub

      A versão no topo da lista é a versão mais recente. Se ela não tiver um -rc (abreviação de “Release Candidate”) no nome, isso significa que é uma versão estável e segura para uso. Clique na versão que você deseja baixar para acessar a página de release dessa versão. Em seguida, clique com o botão direito do mouse no botão Source code (tar.gz) e copie o link para a sua área de transferência.

      Copy Source Code Link

      Agora vamos usar o comando wget em nosso servidor CentOS para baixar o arquivo fonte do link que copiamos, renomeando-o para git.tar.gz no processo, para que seja mais fácil trabalhar com ele.

      Nota: a URL que você copiou pode ser diferente da minha, pois a versão que você baixou pode ser diferente.

      wget https://github.com/git/git/archive/v2.1.2.tar.gz -O git.tar.gz
      

      Quando o download estiver concluído, podemos descompactar o arquivo fonte usando o tar. Vamos precisar de algumas flags extras para garantir que a descompactação seja feita corretamente: z descompacta o arquivo (já que todos os arquivos .gz são compactados), x extrai os arquivos e pastas individuais do arquivo, e f diz ao tar que estamos declarando um nome de arquivo para trabalhar.

      tar -zxf git.tar.gz
      

      Isto irá descompactar o código-fonte compactado para uma pasta com o nome da versão do Git que baixamos (neste exemplo, a versão é 2.1.2, então a pasta é nomeada como git-2.1.2). Precisamos nos mover para essa pasta para começar a configurar nossa compilação. Em vez de nos preocuparmos com o nome completo da versão na pasta, podemos usar um caractere curinga (*) para nos poupar de algum problema ao mudar para essa pasta.

      cd git-*
      

      Uma vez que estivermos na pasta de fontes, podemos começar o processo de compilação. Isso começa com algumas verificações de pré-compilação para coisas como dependências de software e configurações de hardware. Podemos verificar tudo o que precisamos com o script configure gerado pelo make configure. Este script também usará um --prefix para declarar /usr/local (a pasta padrão do programa para plataformas Linux) como o destino apropriado para o novo binário, e criará um Makefile para ser usado no passo seguinte.

      make configure
      ./configure --prefix=/usr/local
      

      Makefiles são arquivos de configuração de script que são processados pelo utilitário make. Nosso Makefile dirá ao make como compilar um programa e vinculá-lo à nossa instalação do CentOS, para que possamos executar o programa corretamente. Com um Makefile pronto, agora podemos executar make install (com privilégios sudo) para compilar o código-fonte em um programa funcional e instalá-lo em nosso servidor:

      sudo make install
      

      O Git deve agora ser compilado e instalado em seu servidor CentOS 7. Para verificar novamente se está funcionando corretamente, tente executar a verificação de versão integrada do Git:

      git --version
      

      Se essa verificação produziu um número de versão do Git, então você pode passar para Configurando o Git abaixo.

      Configurando o Git

      Agora que você tem o git instalado, você precisará enviar algumas informações sobre si mesmo para que as mensagens de commit sejam geradas com as informações corretas anexadas. Para fazer isso, use o comando git config para fornecer o nome e o endereço de e-mail que você gostaria de ter registrado em seus commits:

      git config --global user.name "Seu Nome"
      git config --global user.email "voce@example.com"
      

      Para confirmar que essas configurações foram adicionadas com sucesso, podemos ver todos os itens de configuração que foram definidos, digitando:

      git config --list
      
      user.name=Seu Nome
      user.email=voce@example.com
      

      Essa configuração te poupará do trabalho de ver uma mensagem de erro e ter que revisar os commits após submetê-los.

      Conclusão

      Agora você deve ter o git instalado e pronto para uso em seu sistema. Para saber mais sobre como usar o Git, confira estes artigos mais detalhados:



      Source link

      Como Instalar o Go e Configurar um Ambiente de Programação Local no macOS


      Introdução

      Go é uma linguagem de programação que nasceu da frustração no Google. Os desenvolvedores precisavam escolher continuamente uma linguagem que fosse executada com eficiência, mas demoravam muito tempo para compilar ou escolher uma linguagem fácil de programar, mas que era executada de forma ineficiente em produção. O Go foi projetado para ter todas as três características disponíveis ao mesmo tempo: compilação rápida, facilidade de programação e execução eficiente em produção.

      Embora o Go seja uma linguagem de programação versátil que pode ser usada para muitos projetos de programação diferentes, ela é particularmente adequada para programas de rede/sistemas distribuídos e ganhou a reputação de ser “a linguagem da nuvem”. Ela se concentra em ajudar o programador moderno a fazer mais com um conjunto forte de ferramentas, removendo debates sobre formatação ao tornar o formato parte da especificação da linguagem, bem como ao facilitar o deploy ao compilar para um único binário. O Go é fácil de aprender, com um conjunto muito pequeno de palavras-chave, o que o torna uma ótima opção para iniciantes e igualmente para desenvolvedores experientes.

      Este tutorial irá guiá-lo pela instalação do Go em sua máquina local com macOS e da configuração de um workspace de programação através da linha de comando.

      Pré-requisitos

      Você precisará de um computador com macOS com acesso administrativo e que esteja conectado à Internet.

      Passo 1 — Abrindo o Terminal

      Você estará concluindo a instalação e a configuração na linha de comando, que é uma maneira não gráfica de interagir com seu computador. Ou seja, em vez de clicar nos botões, você digitará texto e receberá retornos do seu computador por meio de texto também. A linha de comando, também conhecida como shell, pode ajudá-lo a modificar e automatizar muitas das tarefas que você faz em um computador todos os dias, e é uma ferramenta essencial para desenvolvedores de software.

      O Terminal do macOS é um aplicativo que você pode usar para acessar a interface da linha de comando. Como qualquer outro aplicativo, você pode encontrá-lo indo até o Finder, navegando até a pasta Aplicativos e, em seguida, na pasta Utilitários. A partir daqui, dê um clique duplo no Terminal como qualquer outro aplicativo para abri-lo. Alternativamente, você pode usar o Spotlight mantendo pressionadas as teclas CMD e SPACE para localizar o Terminal digitando-o na caixa que aparece.

      macOS Terminal

      Existem muitos outros comandos do Terminal para aprender que podem permitir que você faça coisas mais poderosas. O artigo “An Introduction to the Linux Terminal” pode te orientar melhor com o terminal do Linux, que é semelhante ao teminal do macOS.

      Agora que você abriu o Terminal, pode fazer o download e instalar o Xcode, um pacote de ferramentas de desenvolvedor que você precisará para instalar o Go.

      Passo 2 — Instalando o Xcode

      O Xcode é um integrated development environment ou ambiente de desenvolvimento integrado (IDE) composto de ferramentas de desenvolvimento de software para macOS. Você pode verificar se o Xcode já está instalado, digitando o seguinte na janela do Terminal:

      A saída a seguir significa que o Xcode está instalado:

      Output

      /Library/Developer/CommandLineTools

      Se você recebeu um erro em seu navegador web, instale o Xcode a partir da App Store e aceite as opções padrão.

      Quando o Xcode estiver instalado, retorne à janela do Terminal. Em seguida, você precisará instalar o app separado de Ferramentas de Linha de Comando do Xcode, que pode ser feito digitando:

      Neste ponto, o Xcode e seu app de Ferramentas de Linha de Comando estão totalmente instalados e estamos prontos para instalar o gerenciador de pacotes Homebrew.

      Passo 3 — Instalando e Configurando o Homebrew

      Embora o Terminal do macOS tenha muitas das funcionalidades dos Terminais Linux e de outros sistemas Unix, ele não é fornecido com um gerenciador de pacotes que acomoda as melhores práticas. Um gerenciador de pacotes é uma coleção de ferramentas de software que trabalham para automatizar processos de instalação que incluem instalação inicial de software, atualização e configuração de software, e remoção de software conforme necessário. Eles mantêm instalações em um local central e podem manter todos os pacotes de software no sistema em formatos comumente usados. Homebrew fornece ao macOS um sistema gerenciador de pacotes de software livre e de código aberto que simplifica a instalação de software no macOS.

      Para instalar o Homebrew, digite isso na sua janela de Terminal:

      • /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

      O Homebrew é feito em Ruby, assim ele irá modificar o caminho do Ruby do seu computador. O comando curl baixa um script da URL especificada. Este script explicará o que ele fará e, em seguida, fará uma pausa no processo para solicitar sua confirmação. Isso lhe fornece uma série de comentários sobre o que o script vai fazer no seu sistema e dá a você a oportunidade de verificar o processo.

      Se você precisar digitar sua senha, observe que suas teclas não serão exibidas na janela do Terminal, mas serão gravadas. Basta pressionar a tecla return ou enter depois de inserir sua senha. Caso contrário, pressione a letra y para “sim” quando você for solicitado a confirmar a instalação.

      Vamos dar uma olhada nas flags associadas ao comando curl:

      • A flag -f ou --fail informa à janela do Terminal para não dar saída de documento HTML nos erros de servidor.
      • A flag -s ou --silent silencia o curl para que ele não mostre o medidor de progresso, e combinada com a flag -S ou --show-error ela irá assegurar que curl mostre uma mensagem de erro se falhar.
      • A flag -L ou --location informará ao curl para refazer a solicitação para um novo local se o servidor informar que a página solicitada foi movida para um local diferente.

      Quando o processo de instalação estiver concluído, colocaremos o diretório Homebrew no começo da variável de ambiente PATH. Isso garantirá que as instalações do Homebrew serão chamadas antes das ferramentas que o macOS possa selecionar automaticamente e que podem ser executadas em contraposição ao ambiente de desenvolvimento que estamos criando.

      Você deve criar ou abrir o arquivo ~/.bash_profile com o editor de texto de linha de comando nano usando o comando nano:

      Quando o arquivo abrir na janela do Terminal, escreva o seguinte:

      export PATH=/usr/local/bin:$PATH
      

      Para salvar suas alterações, mantenha pressionada a tecla CTRL e a letra o e, quando solicitado, pressione a tecla RETURN. Agora você pode sair do nano segurando a tecla CTRL e a letra x.

      Ative essas alterações executando o seguinte no Terminal:

      Depois de fazer isso, as alterações feitas na variável de ambiente PATH entrarão em vigor.

      Você pode ter certeza de que o Homebrew foi instalado com sucesso digitando:

      Se nenhuma atualização for necessária neste momento, a saída do Terminal mostrará:

      Output

      Your system is ready to brew.

      Caso contrário, você pode receber um aviso para executar outro comando, como brew update, para garantir que sua instalação do Homebrew esteja atualizada.

      Uma vez que o Homebrew está pronto, você pode instalar o Go.

      Passo 4 — Instalando o Go

      Você pode usar o Homebrew para procurar por todos os pacotes disponíveis com o comando brew search. Para o propósito deste tutorial, você irá procurar por pacotes ou módulos relacionados ao Go:

      Nota: Este tutorial não usa brew search go, pois isso retorna muitos resultados. Como go é uma palavra muito pequena e combinaria com muitos pacotes, tornou-se comum usar golang como termo de busca. Essa é uma prática comum quando se pesquisa na Internet por artigos relacionados ao Go também. O termo Golang nasceu a partir do domínio para o Go, que é golang.org.

      O Terminal mostrará uma lista do que você pode instalar:

      Output

      golang golang-migrate

      O Go estará entre os itens da lista. Vá em frente e instale-o:

      A janela do Terminal lhe dará feedback sobre o processo de instalação do Go. Pode demorar alguns minutos antes da conclusão da instalação.

      Para verificar a versão do Go que você instalou, digite o seguinte:

      Isso mostrará a versão específica do Go que está atualmente instalada, que por padrão será a versão mais atualizada e estável do Go disponível.

      No futuro, para atualizar o Go, você pode executar os seguintes comandos para atualizar o Homebrew e depois atualizar o Go. Você não precisa fazer isso agora, pois acabou de instalar a versão mais recente:

      • brew update
      • brew upgrade golang

      brew update atualizará as fórmulas para o próprio Homebrew, garantindo que você tenha as informações mais recentes sobre os pacotes que deseja instalar. brew upgrade golang atualizará o pacote golang para a sua última versão.

      É uma boa prática garantir que sua versão do Go esteja atualizada.

      Com o Go instalado no seu computador, você está pronto para criar um workspace para seus projetos de Go.

      Passo 5 — Criando o seu Workspace Go

      Agora que você tem o Xcode, Homebrew e Go instalados, você pode criar seu workspace de programação.

      O workspace do Go conterá dois diretórios em sua raiz:

      • src: O diretório que contém os arquivos-fonte do Go. Um arquivo-fonte é um arquivo que você escreve usando a linguagem de programação Go. Arquivos-fonte são usados pelo compilador Go para criar um arquivo binário executável.
      • bin: O diretório que contém executáveis compilados e instalados pelas ferramentas Go. Executáveis são arquivos binários que são executados em seu sistema e executam tarefas. Estes são normalmente os programas compilados a partir do seu código-fonte ou outro código-fonte Go baixado.

      O subdiretório src pode conter vários repositórios de controle de versão (tais como o Git, o Mercurial, e o Bazaar). Você verá diretórios como github.com, golang.org ou outros quando seu programa importar bibliotecas de terceiros. Se você estiver usando um repositório de código como o github.com, você também colocará seus projetos e arquivos-fonte nesse diretório. Isso permite uma importação canônica de código em seu projeto. As importações Canônicas são importações que fazem referência a um pacote completo, como o github.com/digitalocean/godo.

      Aqui está como pode se parecer um workspace típico:

      .
      ├── bin
      │   ├── buffalo                                      # comando executável
      │   ├── dlv                                          # comando executável
      │   └── packr                                        # comando executável
      └── src
          └── github.com
              └── digitalocean
                  └── godo
                      ├── .git                            # metadados do repositório do Git
                      ├── account.go                      # fonte do pacote
                      ├── account_test.go                 # fonte do teste
                      ├── ...
                      ├── timestamp.go
                      ├── timestamp_test.go
                      └── util
                          ├── droplet.go
                          └── droplet_test.go
      

      O diretório padrão para o workspace Go a partir da versão 1.8 é o diretório home do usuário com um subdiretório go ou $HOME/go. Se você estiver usando uma versão anterior à 1.8 do Go, ainda é considerado uma boa prática usar o local $HOME/go para o seu workspace.

      Execute o seguinte comando para criar a estrutura de diretórios para o seu workspace Go:

      • mkdir -p $HOME/go/{bin,src}

      A opção -p diz ao mkdir para criar todos os subdiretórios no diretório, mesmo que eles não existam atualmente. A utilização do {bin, src} cria um conjunto de argumentos para mkdir e diz para ele criar tanto o diretóriobin quanto o diretório src.

      Isso garantirá que a seguinte estrutura de diretórios esteja em vigor:

      └── $HOME
          └── go
              ├── bin
              └── src
      

      Antes do Go 1.8, era necessário definir uma variável de ambiente local chamada $GOPATH. Embora não seja mais explicitamente exigido fazer isso, ainda é considerada uma boa prática, pois muitas ferramentas de terceiros ainda dependem da configuração dessa variável.

      Você pode definir seu $GOPATH adicionando-o ao seu ~/.bash_profile.

      Primeiro, abra ~/.bash_profile com o nano ou seu editor de texto preferido:

      Defina seu $GOPATH adicionando o seguinte ao arquivo:

      ~/.bash_profile

      export GOPATH=$HOME/go
      

      Quando o Go compila e instala ferramentas, ele as coloca no diretório $GOPATH/bin. Por conveniência, é comum adicionar o subdiretório /bin do workspace ao seu PATH no seu arquivo ~/.bash_profile:

      ~/.bash_profile

      export PATH=$PATH:$GOPATH/bin
      

      Agora você deve ter as seguintes entradas no seu ~/.bash_profile:

      ~/.bash_profile

      export GOPATH=$HOME/go
      export PATH=$PATH:$GOPATH/bin
      

      Agora, isso permitirá que você execute todos os programas compilados ou baixados por meio das ferramentas Go em qualquer parte do seu sistema.

      Para atualizar seu shell, execute o seguinte comando para carregar as variáveis globais que você acabou de criar:

      Você pode verificar que seu $PATH está atualizado usando o comando echo e inspecionando a saída:

      Você deve ver seu $GOPATH/bin, que aparecerá no seu diretório home. Se você estivesse logado como sammy, você veria /Users/sammy/go/bin no caminho.

      Output

      /Users/sammy/go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

      Agora que você tem a raiz do workspace criada e sua variável de ambiente $GOPATH definida, você pode criar seus projetos futuros com a seguinte estrutura de diretórios. Este exemplo assume que você está usando o github.com como seu repositório:

      $GOPATH/src/github.com/username/project
      

      Se você estivesse trabalhando no projeto https://github.com/digitalocean/godo, você iria colocá-lo no seguinte diretório:

      $GOPATH/src/github.com/digitalocean/godo
      

      Estruturar seus projetos dessa maneira tornará os projetos disponíveis com a ferramenta go get. Isso também ajudará a legibilidade mais tarde.

      Você pode verificar isso usando o comando go get para buscar a biblioteca godo:

      • go get github.com/digitalocean/godo

      Você pode ver se baixou com sucesso o pacote godo listando o diretório:

      • ls -l $GOPATH/src/github.com/digitalocean/godo

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

      Output

      -rw-r--r-- 1 sammy staff 2892 Apr 5 15:56 CHANGELOG.md -rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 CONTRIBUTING.md . . . -rw-r--r-- 1 sammy staff 4893 Apr 5 15:56 vpcs.go -rw-r--r-- 1 sammy staff 4091 Apr 5 15:56 vpcs_test.go

      Neste passo, você criou um workspace Go e configurou as variáveis de ambiente necessárias. No próximo passo, você testará o workspace com algum código.

      Passo 6 — Criando um Programa Simples

      Agora que você tem o workspace Go configurado, é hora de criar um simples programa “Hello, World!”. Isso garantirá que o workspace esteja configurado corretamente e também lhe dará a oportunidade de se familiarizar com o Go.

      Como estamos criando um único arquivo-fonte Go, e não um projeto real, não precisamos estar em nosso workspace para fazer isso.

      A partir do seu diretório home, abra um editor de texto de linha de comando, como o nano, e crie um novo arquivo:

      Quando o arquivo de texto abrir no Terminal, digite seu programa:

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Hello, World!")
      }
      

      Saia do nano pressionando as teclas control e x, e quando solicitado a salvar o arquivo, pressione y.

      Este código usará o pacote fmt e chamará a função Println com Hello, World! como argumento. Isso fará com que a frase Hello, World! seja impressa no terminal quando o programa for executado.

      Ao sair do nano e retornar ao seu shell, execute o programa:

      O programa hello.go que você acabou de criar fará com que o Terminal produza a seguinte saída:

      Output

      Hello, World!

      Neste passo, você usou um programa básico para verificar se seu workspace Go está configurado corretamente.

      Conclusão

      Parabéns! Neste ponto, você tem um workspace de programação Go configurado em sua máquina local com macOS e pode começar um projeto de codificação!



      Source link