One place for hosting & domains

      How To Install Ruby on Rails with rbenv on macOS


      Introduction

      Ruby on Rails is a popular application stack for developers looking to create sites and web apps. The Ruby programming language, combined with the Rails development framework, makes app development quick and efficient.

      One way to install Ruby and Rails is with the command-line tool rbenv. Using rbenv will provide you with a well-controlled and robust environment for developing your Ruby on Rails applications, allowing you to easily switch the version of Ruby for your entire team when needed.

      rbenv provides support for specifying application-specific versions of Ruby, lets you change the global Ruby for each user, and allows you to use an environment variable to override the Ruby version.

      In this tutorial, you will use rbenv to install and set up Ruby on Rails on your local macOS machine.

      Prerequisites

      To follow this tutorial, you will need:

      Step 1 — Installing rbenv

      In this step, you will install rbenv and make sure that it starts automatically at boot. To do this on macOS, this tutorial will use the package manager Homebrew.

      To download the rbenv package with Homebrew, run the following command:

      This will install rbenv and the ruby-build plugin. This plugin adds therbenv install command, which streamlines the installation process for new versions of Ruby.

      Next, you'll add the command eval "$(rbenv init -)" to your ~/.bash_profile file to make rbenv load automatically when you open up the Terminal. To do this, open your .bash_profile in your favorite text editor:

      Add the following line to the file:

      ~/.bash_profile

      eval "$(rbenv init -)"
      

      Save and quit the file.

      Next, apply the changes you made to your ~/.bash_profile file to your current shell session:

      To verify that rbenv is set up properly, use the type command, which will display more information about the rbenv command:

      Your terminal window will display the following:

      Output

      rbenv is a function rbenv () { local command; command="${1:-}"; if [ "$#" -gt 0 ]; then shift; fi; case "$command" in rehash | shell) eval "$(rbenv "sh-$command" "$@")" ;; *) command rbenv "$command" "$@" ;; esac }

      At this point, you have both rbenv and ruby-build installed on your machine. This will allow you to install Ruby from the command line in the next step.

      Step 2 — Installing Ruby

      With the ruby-build plugin now installed, you can install any version of Ruby you may need through a single command. In this step, you will choose a version of Ruby, install it on your machine, and then verify the installation.

      First, use the -l flag to list all the available versions of Ruby:

      The output of that command will be a long list of versions that you can choose to install.

      For this tutorial, install Ruby 2.6.3:

      Installing Ruby can be a lengthy process, so be prepared for the installation to take some time to complete.

      Once it's done installing, set it as your default version of Ruby with the global sub-command:

      Verify that Ruby was properly installed by checking its version number:

      Your output will look something like this:

      Output

      ruby 2.6.3p62 (2019-04-16 revision 67580) [x86_64-darwin18]

      To install and use a different version of Ruby, run the rbenv commands with a different version number, such as rbenv install 2.3.0 and rbenv global 2.3.0.

      You now have one version of Ruby installed and have set your default Ruby version. Next, you will set yourself up to work with Ruby packages and libraries, or gems, which will then allow you to install Rails.

      Step 3 — Working with Gems

      Gems are packages of Ruby libraries and programs that can be distributed throughout the Ruby ecosystem. You use the gem command to manage these gems. In this step, you will configure the gem command to prepare for the Rails installation.

      When you install a gem, the installation process generates local documentation. This can add a significant amount of time to each gem's installation process, so turn off local documentation generation by creating a file called ~/.gemrc which contains a configuration setting to turn off this feature:

      • echo "gem: --no-document" > ~/.gemrc

      With that done, use the gem command to install Bundler, a tool that manages gem dependencies for projects. This is needed for Rails to work correctly:

      You'll see output like this:

      Output

      Fetching: bundler-2.0.2.gem Successfully installed bundler-2.0.2 1 gem installed

      You can use the gem env command to learn more about the environment and configuration of gems. To see the location of installed gems, use the home argument, like this:

      You'll see output similar to this:

      /Users/sammy/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0
      

      Now that you have set up and explored your gem workflow, you are free to install Rails.

      Step 4 — Installing Rails

      In this step, you will install Rails, verify the installation, and prepare it for use.

      To install the most recent version of Rails, use the gem install command:

      The gem command installs the gem you specify, as well as every dependency. Rails is a complex web development framework and has many dependencies, so the process will take some time to complete. Eventually you'll see a message stating that Rails is installed, along with its dependencies:

      Output

      ... Successfully installed rails-5.2.3 38 gems installed

      Note: If you would like to install a specific version of Rails, you can list its valid versions by doing a search, which will output a long list of options:

      • gem search '^rails$' --all

      You could then install a specific version, such as 4.2.7:

      • gem install rails -v 4.2.7

      rbenv works by creating a directory of shims, or libraries that intercept calls and change or redirect them. In this case, shims point Ruby commands to the files used by the Ruby version that's currently enabled. Through the rehash sub-command, rbenv maintains shims in that directory to match every Ruby command across every installed version of Ruby on your server. Whenever you install a new version of Ruby or a gem that provides commands, such as Rails, you should use rehash.

      To rehash the directory of shims, run the following command:

      Verify your installation of Rails by printing its version with this command:

      You will see the version of Rails that was installed:

      Output

      Rails 5.2.3

      With Rails successfully installed, you can begin testing your Ruby on Rails installation and start to develop web applications. In the next step, you will learn how to update and uninstall rbenv and Ruby.

      Step 5 — Updating and Uninstalling rbenv and Ruby

      When maintaining projects, it is useful to know how to update and uninstall when the need arises. In this step, you will upgrade rbenv, then uninstall Ruby and rbenv from your machine.

      You can upgrade rbenv and ruby-build using Homebrew by running the following command:

      • brew upgrade rbenv ruby-build

      If rbenv or ruby-build need to be updated, Homebrew will do it for you automatically. If your set up is already up to date, you will get output similar to the following:

      Output

      Error: rbenv 1.1.2 already installed Error: ruby-build 20190615 already installed

      This will ensure that we are using the most up-to-date version of rbenv available.

      As you download additional versions of Ruby, you may accumulate more versions than you would like in your ~/.rbenv/versions directory. Using the ruby-build plugin's uninstall subcommand, you can remove these previous versions.

      For example, run the following to uninstall Ruby version 2.1.3:

      With the rbenv uninstall command you can clean up old versions of Ruby so that you do not have more installed than you are currently using.

      If you've decided you no longer want to use rbenv, you can remove it from your system.

      To do this, first open your ~/.bash_profile file in your editor:

      Find and remove the following line from the file to stop rbenv from starting when you open the Terminal:

      ~/.bash_profile

      ...
      eval "$(rbenv init -)"
      

      Once you have deleted this line, save the file and exit the editor.

      Run the following command to apply the changes to your shell:

      Next, remove rbenv and all installed Ruby versions with this command:

      Finally, remove the rbenv package itself with Homebrew:

      Check the rbenv version to make sure that it has been uninstalled:

      You will get the following output:

      Output

      -bash: /usr/local/bin/rbenv: No such file or directory

      This means that you have successfully removed rbenv from your machine.

      Conclusion

      In this tutorial you installed Ruby on Rails with rbenv on macOS. From here, you can learn more about coding in Ruby with our How To Code in Ruby series. You can also explore how to use Ruby on Rails with PostgreSQL rather than its default sqlite3 database, which provides more scalability, centralization, and stability for your applications.



      Source link

      How To Use PostgreSQL with Your Ruby on Rails Application on macOS


      Introduction

      When using the Ruby on Rails web framework, your application is set up by default to use SQLite as a database. SQLite is a lightweight, portable, and user-friendly relational database that performs especially well in low-memory environments, and will work well in many cases. However, for highly complex applications that need more reliable data integrity and programmatic extensibility, a PostgreSQL database will be a more robust and flexible choice. In order to configure your Ruby on Rails setup to use PostgreSQL, you will need to perform a few additional steps to get it up and running.

      In this tutorial, you will set up a Ruby on Rails development environment connected to a PostgreSQL database on a local macOS machine. You will install and configure PostgreSQL, and then test your setup by creating a Rails application that uses PostgreSQL as its database server.

      Prerequisites

      This tutorial requires the following:

      • One computer or virtual machine with macOS installed, with administrative access to that machine and an internet connection. This tutorial has been tested on macOS 10.14 Mojave.

      • A Ruby on Rails development environment installed on your macOS machine. To set this up, follow our guide on How To Install Ruby on Rails with rbenv on macOS. This tutorial will use version 2.6.3 of Ruby and 5.2.3 of Rails; for information on the latest versions, check out the official sites for Ruby and Rails.

      Step 1 — Installing PostgreSQL

      In order to configure Ruby on Rails to create your web application with PostgreSQL as a database, you will first install the database onto your machine. Although there are many ways to install PostgreSQL on macOS, this tutorial will use the package manager Homebrew.

      There are multiple Homebrew packages to install different versions of PostgreSQL. To install the latest version, run the following command:

      If you would like to download a specific version of PostgreSQL, replace postgresql in the previous command with your desired package. You can find the available packages at the Homebrew website.

      Next, include the PostgreSQL binary in your PATH variable in order to access the PostgreSQL command line tools, making sure to replace the 10 with the version number you are using:

      • echo 'export PATH="/usr/local/opt/postgresql@10/bin:$PATH"' >> ~/.bash_profile

      Then, apply the changes you made to your ~/.bash_profile file to your current shell session:

      To start the service and enable it to start at login, run the following:

      • brew services start postgresql@10

      Check to make sure the installation was successful:

      You will get the following output:

      Output

      postgres (PostgreSQL) 10.9

      Once PostgreSQL is installed, the next step is to create a role that your Rails application will use later to create your database.

      Step 2 — Creating a Database Role for Your Application

      In PostgreSQL, roles can be used to organize permissions and authorization. When starting PostgreSQL with Homebrew, you will automatically have a superuser role created with your macOS username. In order to keep these superuser privileges separate from the database instance you use for your Rails application, in this step you will create a new role with less access.

      To create a new role, run the following command, replacing appname with whatever name you'd like to give the role:

      In this command, you used createuser to create a role named appname. The -d flag gave the role the permission to create new databases.

      You also specified the -P flag, which means you will be prompted to enter a password for your new role. Enter your desired password, making sure to record it so that you can use it in a configuration file in a future step.

      If you did not use the -P flag and want to set a password for the role after you create it, enter the PostgreSQL console with the following command:

      You will receive the following output, along with the prompt for the PostgreSQL console:

      Output

      psql (10.9) Type "help" for help. postgres=#

      The PostgreSQL console is indicated by the postgres=# prompt. At the PostgreSQL prompt, enter this command to set the password for the new database role, replacing the highlighted name with the one you created:

      PostgreSQL will prompt you for a password. Enter your desired password at the prompt, then confirm it.

      Now, exit the PostgreSQL console by entering this command:

      Your usual prompt will now reappear.

      In this step, you created a new PostgreSQL role without superuser privileges for your application. Now you are ready to create a new Rails app that uses this role to create a database.

      Step 3 — Creating a New Rails Application

      With your role configured for PostgreSQL, you can now create a new Rails application that is set up to use PostgreSQL as a database.

      First, navigate to your home directory:

      Create a new Rails application in this directory, replacing appname with whatever you would like to call your app:

      • rails new appname -d=postgresql

      The -d=postgresql option sets PostgreSQL as the database.

      Once you've run this command, a new folder named appname will appear in your home directory, containing all the elements of a basic Rails application.

      Next, move into the application's directory:

      Now that you have created a new Rails application and have moved into the root directory for your project, you can configure and create your PostgreSQL database from within your Rails app.

      Step 4 — Configuring and Creating Your Database

      When creating the development and test databases for your application, Rails will use the PostgreSQL role that you created in Step 2. To make sure that Rails creates these databases, you will alter the database configuration file of your project. You will then create your databases.

      One of the configuration changes to make in your Rails application is to add the password for the PostgreSQL role you created in the last step. To keep sensitive information like passwords safe, it is a good idea to store this in an environment variable rather than to write it directly in your configuration file.

      To store your password in an environment variable at login, run the following command, replacing APPNAME with the name of your app and PostgreSQL_Role_Password with the password you created in the last step:

      • echo 'export APPNAME_DATABASE_PASSWORD="PostgreSQL_Role_Password"' >> ~/.bash_profile

      This command writes the export command to your ~/.bash_profile file so that the environment variable will be set at login.

      To export the variable for your current session, use the source command:

      Now that you have stored your password in your environment, it's time to alter the configuration file.

      Open your application's database configuration file in your preferred text editor. This tutorial will use nano:

      Under the default section, find the line that says pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %> and add the following highlighted lines, filling in your credentials and the environment variable you created. It should look something like this:

      config/database.yml

      ...
      default: &default
        adapter: postgresql
        encoding: unicode
        # For details on connection pooling, see Rails configuration guide
        # http://guides.rubyonrails.org/configuring.html#database-pooling
        pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
        username: appname
        password: <%= ENV['APPNAME_DATABASE_PASSWORD'] %>
      
      development:
        <<: *default
        database: appname_development
      ...
      

      This will make the Rails application run the database with the correct role and password. Save and exit by pressing CTRL+X, Y, then ENTER.

      For more information on configuring databases in Rails, see the Rails documentation.

      Now that you have made changes to config/database.yml, create your application's databases by using the rails command:

      Once Rails creates the database, you will receive the following output:

      Output

      Created database 'appname_development' Created database 'appname_test'

      As the output suggests, this command created a development and test database in your PostgreSQL server.

      You now have a PostgreSQL database connected to your Rails app. To ensure that your application is working, the next step is to test your configuration.

      Step 5 — Testing Your Configuration

      To test that your application is able to use the PostgreSQL database, try to run your web application so that it will show up in a browser.

      First, you'll use the built-in web server for Rails, Puma, to serve your application. This web server comes with Rails automatically and requires no additional setup. To serve your application, run the following command:

      • rails server --binding=127.0.0.1

      --binding binds your application to a specified IP. By default, this flag will bind Rails to 0.0.0.0, but since this means that Rails will listen to all interfaces, it is more secure to use 127.0.0.1 to specify the localhost. By default, the application listens on port 3000.

      Once your Rails app is running, your command prompt will disappear, replaced by this output:

      Output

      => Booting Puma => Rails 5.2.3 application starting in development => Run `rails server -h` for more startup options Puma starting in single mode... * Version 3.12.1 (ruby 2.6.3-p62), codename: Llamas in Pajamas * Min threads: 5, max threads: 5 * Environment: development * Listening on tcp://127.0.0.1:3000 Use Ctrl-C to stop

      To test if your application is running, open up a new terminal window on your server and use the curl command to send a request to 127.0.0.1:3000:

      • curl http://127.0.0.1:3000

      You will receive a lot of output in HTML, ending in something like:

      Output

      ... <strong>Rails version:</strong> 5.2.3<br /> <strong>Ruby version:</strong> 2.6.3 (x86_64-darwin18) </p> </section> </div> </body> </html>

      You can also access your Rails application in a local web browser by visiting:

      http://127.0.0.1:3000
      

      At this URL, you will find a Ruby on Rails welcome page:

      Ruby on Rails Welcome Page

      This means that your application is properly configured and connected to the PostgreSQL database.

      Conclusion

      In this tutorial, you created a Ruby on Rails web application that was configured to use PostgreSQL as a database on a local macOS machine. If you would like to learn more about the Ruby programming language, check out our How To Code in Ruby series.

      For more information on choosing a database for your application, check out our tutorial on the differences between and use cases of SQLite, PostgreSQL, and MySQL. If you want to read more about how to use databases, see our An Introduction to Queries in PostgreSQL article, or explore DigitalOcean's Managed Databases product.



      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