One place for hosting & domains


      How To Create SSH Keys with OpenSSH on macOS, Linux, or Windows Subsystem for Linux


      When setting up a remote Linux server, you’ll need to decide upon a method for securely connecting to it. While passwords are one way of verifying a user’s identity, passwords have multiple vulnerabilities and can be cracked by a brute force attack. Secure Shell keys — better known as SSH keys — are often used instead of passwords, as they offer a more secure method of connecting to remote Linux servers. As part of the Secure Shell cryptographic network protocol, SSH keys also enable users to securely perform network services over an unsecured network, such as delivering text-based commands to a remote server or configuring its services.

      This tutorial will guide you through the steps of creating SSH keys with OpenSSH, a suite of open source SSH tools, on macOS and Linux, as well as on Windows through the use of the Windows Subsystem for Linux. It is written for an audience that is just getting started with the command line and will provide guidance on accessing the terminal on a personal computer. After completing this tutorial, you will have SSH keys that can be used to securely set up a server in the tutorial How To Set Up an Ubuntu 20.04 Server on a DigitalOcean Droplet that is part of the Introduction to the Cloud Curriculum (coming soon).

      If you are already familiar with the command line and looking for instructions on using SSH to connect to a remote server, please see our collection of tutorials on Setting Up SSH Keys for a range of Linux operating systems.


      To complete this tutorial, you will need:

      • A local machine running one of the following operating systems: macOS, Linux, or Windows with Windows Subsystem for Linux installed. If you are using Windows, you can find instructions for downloading or updating the Windows Subsystem for Linux on Microsoft’s documentation page. Note that while OpenSSH should work for a range of Linux distributions, this tutorial has been tested using Ubuntu 20.04.

      Note: If you are looking for instructions on how to create SSH keys on a Windows machine that does not have the Windows Subsystem for Linux, please visit our product documentation How to Create SSH Keys with PuTTY on Windows.

      • Some familiarity with working with a terminal and the command line. If you need an introduction to working with terminals and the command line, you can visit our guide A Linux Command Line Primer (coming soon).

      Step 1 — Understanding SSH Keys

      SSH keys are two long strings of characters that can be used to authenticate the identity of a user requesting access to a remote server. These keys are generated by the user on their local computer using a SSH utility. One key is private and stored on the user’s local machine. The other key is public and shared with the remote server or any other entity the user wishes to securely communicate with.

      When a user requests to connect to a server with SSH, the server sends a message encrypted with the public key that can only be decrypted by the associated private key. The user’s local machine then uses its private key to attempt to decrypt the message. If the message is successfully decrypted, the server grants the user access without the need of a password. Once authenticated, users can launch a remote shell session in their local terminal to deliver text-based commands to the remote server.

      In the next step, you will open a terminal on your computer so that you can access the SSH utility used to generate a pair of SSH keys.

      Step 2 — Opening a Terminal on Your Computer

      A terminal allows you to interact with your computer through text-based commands rather than a graphical user interface. The way you access the terminal on your computer will depend on what type of operating system you are using.

      On machines running macOS, the Terminal application is typically located in the Utilities folder inside the Applications folder. You can also find it by searching for “terminal” in the Search Spotlight.

      If you are working on a Linux computer, your distribution’s default terminal application is also typically located in the Utilities folder inside the Applications folder. You can also find it by searching for “terminal” with the Desktop search functionality.

      If you are working on a Windows machine running Windows Subsystem for Linux, a Linux terminal should open immediately after installation. You can also find it by searching for “Ubuntu” with the Desktop search functionality.

      Once you have located your system’s terminal application, open up a new terminal window. Your terminal should display your user name, a dollar sign ($), and a cursor. This is where you will begin to type commands to tell the terminal what to do.

      In the next step, you will enter a text-based command to generate a pair of SSH keys.

      Step 3 — Generating Keys With OpenSSH

      Your macOS or Linux operating system should have the standard OpenSSH suite of tools already installed. This suite of tools includes the utility ssh-keygen, which you will use to generate a pair of SSH keys.

      Type the following command into your terminal:

      You will then be prompted to select a location for the keys. By default, the keys are stored in the ~/.ssh directory with the filenames id_rsa for the private key and for the public key. Using the default locations allows your SSH client to automatically find your SSH keys when authenticating, so we recommend accepting these default options. To do so, press ENTER:


      Generating public/private rsa key pair. Enter file in which to save the key (/home/sammy/.ssh/id_rsa):

      Warning: If you have previously generated a key pair, you will be prompted to confirm that you actually want to overwrite the existing key:


      /home/sammy/.ssh/id_rsa already exists. Overwrite (y/n)?

      If you choose to overwrite the key on disk, you will not be able to authenticate using the previous key anymore. Selecting “yes” is an irreversible destructive process.

      If you’re certain that you want to overwrite the existing key on disk, you can do so by pressing Y and then ENTER.

      If you choose the default location, your public key will be located in /home/sammy/.ssh/ and your private key will be located in /home/sammy/.ssh/id_rsa. Note that in your filepath, sammy will be replaced with your username.

      After selecting a location for the key, you’ll be prompted to enter an optional passphrase which encrypts the private key file on disk.

      If you enter a passphrase, you will have to provide it every time you use this key (unless you are running SSH agent software that stores the decrypted key). We recommend using a passphrase, but you can just press ENTER to bypass this prompt:


      Created directory '/home/sammy/.ssh'. Enter passphrase (empty for no passphrase): Enter same passphrase again:

      Following that final prompt, your system will generate the SSH key pair:


      Your identification has been saved in /home/sammy/.ssh/id_rsa. Your public key has been saved in /home/sammy/.ssh/ The key fingerprint is: a9:49:EX:AM:PL:E3:3e:a9:de:4e:77:11:58:b6:90:26 sammy@ The key's randomart image is: +--[ RSA 2048]----+ | ..o | | E o= . | | o. o | | .. | | ..S | | o o. | | =o.+. | |. =++.. | |o=++. | +-----------------+

      You now have a public and private key that you can use to authenticate.


      Congratulations, you have now generated a pair of SSH keys. These keys can be used to securely connect with a remote server and are necessary for the tutorial How To Set Up an Ubuntu 20.04 Server on a DigitalOcean Droplet that follows this tutorial in the Introduction to the Cloud Curriculum (coming soon).

      For a deeper dive on working using SSH, please visit our guide SSH Essentials: Working With SSH Servers, Clients, and Keys.

      Source link

      Trying the New WSL 2. It’s Fast! (Windows Subsystem for Linux)

      In this post, I cover some first impressions from my experience installing and running WSL2 (Windows Subsystem for Linux) in my dev workflow.

      I haven’t done any exhaustive, scientific, or precise tests by any means. What I have found though is that WSL is about 5 times faster for everyday web development tasks like npm or yarn.

      Also, hot reloading and working with create-react-app or the vue-cli is faster!

      Read on for installation, getting started, gotchas, and specific timing on npx create-react-app

      What does WSL 2 bring?

      This is the process I went through and the surprises I encountered while installing.

      Installing WSL2 on Windows 10

      Microsoft now has stable documentation on how to install WSL and update to WSL2.

      To get up and running, follow the guide above through to the point where you set up a new linux distribution.

      Checking if the Install Worked

      The following command will show us what distros we have installed and what version they are on:

      • wsl --list --verbose
      • # or shorthand
      • wsl -l -v

      Installation Failure

      If you already had Ubuntu installed on WSL 1, you may have to completely uninstall and reinstall it.

      If your computer is having trouble running the update command (like my computer), then you may want to completely uninstall and reinstall your distro.

      I went into the Windows settings under Apps > Apps and Features and uninstalled Ubuntu:

      Then I made sure that the default version I wanted for all new installs was version 2:

      • wsl --set-default-version 2

      Now we can go into the Windows Store to install it:

      Once we’re installed, then we can check to be sure that version 2 was installed. Open up Powershell and run:

      Running WSL

      You can open up Windows Terminal and use the Ubuntu dropdown:

      Alternatively you can open up either cmd or Powershell and run:

      • # open up windows subsystem for linux
      • wsl

      Gotchas with WSL 2

      Speed when transferring between file systems is a little slow right now. That’s not a worry for me since I never transferred. I worked solely inside of my Windows files which were mounted into the Linux system.

      Here’s a guide on User Experience changes from WSL 1 to WSL 2. The two big gotchas are:

      1. Move your files into the Linux file system instead of your Windows system
      2. You will need to access localhost apps like [localhost:3000](http://localhost:3000) via an IP address like

      Move all files into Linux

      To take advantage of all the new speed improvements in WSL 2, our files will need to be moved into the Linux filesystem.

      The best way to figure out where to move your files is to find the home directory in Linux, then open it in Windows explorer. Run the following:

      • # find the home folder
      • cd ~
      • # open up windows explorer for this folder
      • explorer.exe .

      Notice the path as a Network path:

      We can now move our files from our Windows folders into this new networked folder. We’ll be able to access it from our WSL and interact with it as if it were still in the same Windows files.

      For instance, we can install Node using a tool like n and then run npm start to run a local server for let’s say a React app.

      Network Isn’t localhost Yet

      When we create an app using create-react-app or the vue-cli, we will usually run a command like yarn start or yarn serve to run a local server.

      Normally we would be able to check on our application right in our browser using [localhost:3000](http://localhost:3000) for React or [localhost:8080](http://localhost:8080) for Vue.

      In the early stages of WSL 2, we can’t use localhost. We need to use an IP since Linux is inside a VM.

      To access your application currently, we will use an IP.

      Notice the We’ll use that to access our application:

      A Quick Comparison and Speed Test

      This entire exercise was to get a setup that was faster than the previous one. Let’s see if this setup is any faster!

      I don’t have anything too scientific. I’ll go back and run more tests, but I was frustrated how long a new React app took WSL 1 to make.

      For now, our test will be to run npx create-react-app my-new-app.

      We’ll be comparing the following machines. I know this isn’t scientific at all. I wish I had more computers with similar setups. I wish I had done these speed tests before I upgraded to WSL 2. Oh well. We have what we have!

      • My desktop machine (super powerful, more than the laptops for sure)
      • Surface Book 2 15" i7
      • MacBook Pro 15" 2015
      • npx create-react-app my-new-app

      Here are the numbers I got from running the test a few times on each platform.

      • Surface Book 2 WSL 1: 257 seconds
      • Surface Book 2 WSL 2: 52 seconds
      • 2015 MacBook Pro: 45 seconds
      • 2018 MacBook Pro: 38 seconds

      While still not as fast as the latest MacBook Pro, WSL 2 has made significant improvements over WSL 1.

      What’s Next?

      We’ll keep getting updates and I’ll keep testing to see if performance is improving. I would love to get to a point where WSL 2 on Windows could be as fast as a 2018 MacBook Pro.

      I love both Windows and Mac platforms and with WSL 2, my tools on both platforms has gotten even closer:

      Happy coding!

      Source link

      Como instalar o Go e configurar um ambiente de programação local no Windows 10


      O Go é uma linguagem de programação que nasceu de frustrações no Google. Os desenvolvedores tinham que escolher continuamente entre uma linguagem eficaz na execução, mas que levava muito tempo para compilar ou escolher uma linguagem fácil de programar, mas que não era eficaz na produção. A linguagem Go foi projetada para ter todas as três vantagens disponíveis ao mesmo tempo: velocidade de compilação, facilidade da programação e a eficiência da execução na 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 é adequada particularmente para programas de sistemas de rede/distribuídos e ganhou uma reputação como “a linguagem da nuvem”. Essa linguagem se dedica a ajudar o programador moderno a produzir mais com um conjunto forte de ferramentas, tirando de cena os debates sobre a formatação e fazendo da formatação parte das especificações da linguagem, além de tornar a implantação fácil por meio da compilação em um binário único. A linguagem Go é fácil de aprender, com uma série pequena de palavras-chave que a tornam uma ótima escolha tanto para desenvolvedores iniciantes, quanto para experientes.

      Este tutorial guiará você na instalação do Go em sua máquina local do Windows 10 e na configuração de um ambiente de programação através da linha de comando.


      Você precisará de uma máquina com Windows 10 – com acesso administrativo e conectada à Internet.

      Passo 1 — Abrindo e configurando o PowerShell

      Você concluirá a maior parte da instalação e configuração em uma interface de linha de comando, que é uma maneira não gráfica de interagir com seu computador. Ou seja, em vez de clicar em botões, você vai digitar em texto e receberá o feedback de seu computador por texto também. A linha de comando, também conhecida como shell, pode ajudar você a modificar e automatizar muitas das tarefas que você faz em um computador diariamente. Trata-se de uma ferramenta essencial para os desenvolvedores de software.

      O PowerShell é um programa da Microsoft que fornece uma interface de shell de linha de comando. As tarefas administrativas são realizadas executando cmdlets, pronunciadas command-lets, que são classes especializadas do . NET Framework (software), que pode realizar as operações. De código aberto em agosto de 2016, o PowerShell agora está disponível para uso entre as plataformas, tanto para sistemas em Windows, como em Unix (incluindo Mac e Linux).

      Para encontrar o Windows PowerShell, clique com o botão direito no ícone Start (Iniciar), no canto inferior esquerdo de sua tela. Quando o menu aparecer, clique em Search (Pesquisa) e, em seguida, digite PowerShell na barra de busca. Quando as opções forem exibidas para você, clique com o botão direito no Windows PowerShell do aplicativo Desktop. Para os fins deste tutorial, selecione Run as Administrator (Executar como administrador). Quando a caixa de diálogo surgir com a questão Do you want to allow this app to make changes to your PC? (Deseja permitir que este aplicativo faça alterações no seu computador?) clique em Yes (Sim).

      Assim que fizer isso, verá uma interface baseada em texto que tem uma string de palavras que se parece com esta:

      Windows 10 PowerShell

      Troque de pasta de sistema, digitando o seguinte comando:

      Então, você estará em um diretório home, como o PS C:Userssammy.

      Para continuar com o processo de instalação, primeiro você deve definir as permissões através do PowerShell. Configurado para executar no modo mais seguro por padrão, existem alguns níveis de permissões que você pode configurar como administrador:

      • Restricted (Restrita) é a política de execução padrão. Sob este modo, você não poderá executar scripts e o PowerShell funcionará apenas como uma shell interativa.
      • AllSigned (Todas Assinadas) permitirá que você execute todos os scripts e arquivos de configuração assinados por um fornecedor confiável, o que significa que possivelmente poderia abrir sua máquina para o risco de executar scripts maliciosos que podem ser assinados por um fornecedor confiável.
      • RemoteSigned (Assinatura Remota), permitirá que você execute scripts e arquivos de configuração baixados da Internet - assinados por fornecedores confiáveis, abrindo novamente sua máquina a vulnerabilidades se esses scripts confiáveis, na verdade, forem maliciosos.
      • Unrestricted (Irrestrito) executará todos os scripts e arquivos de configuração baixados da Internet desde que você confirme que entendeu que o arquivo foi baixado da Internet. Neste caso, não será necessária uma assinatura digital. Dessa maneira, você pode estar abrindo sua máquina para o risco de executar scripts não assinados e potencialmente maliciosos baixados da Internet.

      Neste tutorial, você usará a política de execução RemoteSigned para definir as permissões do usuário atual. Isso permitirá que o PowerShell aceite scripts confiáveis sem criar as permissões tão amplas quanto elas seriam com uma permissão Unrestricted. Digite o seguinte no PowerShell:

      • Set-ExecutionPolicy -Scope CurrentUser

      O PowerShell solicitará que você forneça uma política de execução. Digite o seguinte para usar o RemoteSigned:

      Assim que pressionar ENTER, será solicitado que confirme a mudança para a política de execução. Digite a letra y para permitir que as alterações entrem em vigor. Você pode confirmar se isso funcionou, solicitando as permissões atuais na máquina:

      • Get-ExecutionPolicy -List

      Você deve receber um resultado que se parece com este:


      Scope ExecutionPolicy ----- --------------- MachinePolicy Undefined UserPolicy Undefined Process Undefined CurrentUser RemoteSigned LocalMachine Undefined

      Isso confirma que o usuário atual pode executar scripts confiáveis baixados da Internet. Agora, você pode seguir em frente para baixar os arquivos que precisaremos para configurar nosso ambiente de programação em Go.

      Passo 2 — Instalando o gerenciador de pacotes Chocolatey

      Um gerenciador de pacotes é uma coleção de ferramentas de software que funcionam para automatizar processos de instalação. Isso inclui a instalação inicial, o upgrade e a configuração do software, bem como a remoção de software - conforme necessário. Eles mantêm as instalações de software em um local central e podem manter todos os pacotes de software no sistema, nos formatos em que são habitualmente usados.

      O Chocolatey é um gerenciador de pacotes de linha de comando criado para o Windows que funciona como o apt-get funciona no Linux. Disponível em uma versão de código aberto, o Chocolatey ajudará você a instalar aplicativos e ferramentas rapidamente. Você o usará para baixar o que for necessário para o seu ambiente de desenvolvimento.

      Antes de instalar o script, leia-o para confirmar que está satisfeito com as alterações que ele fará em sua máquina. Para fazer isso, use o framework de script .NET para baixar e exibir o script do Chocolatey na janela do seu terminal.

      Comece criando um objeto WebClient chamado $script que compartilha as configurações de conexão da Internet com o Internet Explorer:

      • $script = New-Object Net.WebClient

      Examine as opções disponíveis, canalizando o objeto $script com uma | para a classe Get-Member:

      Isso retornará todos os membros (propriedades e métodos) deste objeto WebClient:

      Snippet of Output

      . . . DownloadFileAsync Method void DownloadFileAsync(uri address, string fileName), void DownloadFileAsync(ur... DownloadFileTaskAsync Method System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileNa... DownloadString Method string DownloadString(string address), string DownloadString(uri address) #method we will use DownloadStringAsync Method void DownloadStringAsync(uri address), void DownloadStringAsync(uri address, Sy... DownloadStringTaskAsync Method System.Threading.Tasks.Task[string] DownloadStringTaskAsync(string address), Sy… . . .

      Examinando o resultado, você consegue identificar o método DownloadString, usado para exibir o script e a assinatura na janela do PowerShell. Use este método para verificar o script:

      • $script.DownloadString("")

      Após verificar o script, instale o Chocolatey, digitando o seguinte no PowerShell:

      • iwr -UseBasicParsing | iex

      O cmdlet iwr, ou Invoke-WebRequest, permite que você extraia dados da Web. Isso passará o script para iex, ou o cmdlet Invoke-Expression, que executará o conteúdo do script e a instalação para o gerenciador de pacotes Chocolatey.

      Permita que o PowerShell instale o Chocolatey. Assim que ele estiver totalmente instalado, comece a instalar as ferramentas adicionais com o comando choco.

      Se você precisar fazer o upgrade do Chocolatey no futuro, execute o seguinte comando:

      Com o gerenciador de pacotes instalado, instale o resto do que for necessário para o ambiente de programação em Go.

      Passo 3 — Instalando o editor de texto Nano (opcional)

      Neste passo, você instalará o nano, um editor de texto que usa uma interface de linha de comando. Você pode usar o nano para escrever programas diretamente dentro do PowerShell. Este não é um passo obrigatório, já que é possível usar um editor de texto com uma interface de usuário gráfica, como o Bloco de notas. Este tutorial recomenda que use o nano, uma vez que ele ajudará você a se acostumar a usar o PowerShell.

      Use o Chocolatey para instalar o nano:

      O identificador -y confirma automaticamente que você deseja executar o script, sem ser solicitado a confirmar.

      Assim que o nano estiver instalado, utilize o comando nano para criar novos arquivos de texto. Você usará isso mais tarde neste tutorial para escrever seu primeiro programa Go.

      Passo 4 — Instalando o Go

      Assim como fez com o nano no passo anterior, você usará o Chocolatey para instalar o Go:

      Nota: como o go é uma palavra muito pequena, tornou-se comum usar golang como um termo para instalar pacotes e procurar artigos relacionados ao Go na Internet. O termo Golang nasceu do domínio para a linguagem Go, que é o

      O PowerShell instalará o Go, gerando resultados dentro do PowerShell durante o processo. Assim que a instalação for concluída, você deve ver o seguinte resultado:


      Environment Vars (like PATH) have changed. Close/reopen your shell to see the changes (or in powershell/cmd.exe just type `refreshenv`). The install of golang was successful. Software installed as 'msi', install location is likely default. Chocolatey installed 1/1 packages. See the log for details (C:ProgramDatachocolateylogschocolatey.log).

      Com a instalação finalizada, você agora confirmará que Go está instalado. Para ver as alterações, feche e abra novamente o PowerShell como administrador e, em seguida, verifique a versão do Go disponível em sua máquina local:

      Você receberá um resultado parecido com este:


      go version go1.12.1 windows/amd643.7.0

      Assim que o Go estiver instalado, você poderá configurar um espaço de trabalho para seus projetos de desenvolvimento.

      Passo 5 — Criando seu espaço de trabalho em Go

      Agora que você tem o Chocolatey, o nano e Go instalados, crie seu espaço de trabalho de programação.

      O espaço de trabalho em Go terá dois diretórios como 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. Os 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 do Go. Os executáveis são arquivos binários que são executados no seu sistema e executam tarefas. Esses são programas tipicamente compilados pelo seu código fonte ou outro código fonte baixado do Go.

      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 o ou quando seu programa importar bibliotecas de terceiros. Se estiver usando um repositório de códigos como o, você também colocará seus projetos e arquivos fonte sob aquele diretório. Isso permite uma importação canônica do código no seu projeto. As importações Canônicas são importações que referenciam um pacote totalmente qualificado, como o

      Aqui está como um espaço de trabalho típico se parece:

      ├── bin
      │   ├── buffalo                                      # command executable
      │   ├── dlv                                          # command executable
      │   └── packr                                        # command executable
      └── src
              └── digitalocean
                  └── godo
                      ├── .git                            # Git repository metadata
                      ├── account.go                      # package source
                      ├── account_test.go                 # test source
                      ├── ...
                      ├── timestamp.go
                      ├── timestamp_test.go
                      └── util
                          ├── droplet.go
                          └── droplet_test.go

      A partir da versão 1.8, o diretório padrão para o espaço de trabalho do Go é o seu diretório home de usuário com um subdiretório go, ou $HOME/go. Se estiver usando uma versão anterior à versão 1.8 do Go, ainda é considerada como melhor prática usar o local $HOME/go como o seu espaço de trabalho.

      Emita o comando seguinte para navegar até o diretório $HOME:

      Em seguida, crie a estrutura de diretório para seu espaço de trabalho do Go:

      Isso garantirá que a seguinte estrutura de diretório em funcionamento:

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

      Antes do Go 1.8, era necessário definir uma variável local do ambiente chamada $GOPATH. Embora já não seja necessário fazer isso, ainda é considerada uma boa prática, já que muitas ferramentas de terceiros ainda precisam que seja definida.

      Como você usou o Chocolatey para a instalação, essa variável de ambiente já deverá estar definida. Verifique isso com o seguinte comando:

      Você deve ver o seguinte resultado, com seu nome de usuário no lugar de sammy:



      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 espaço de trabalho ao seu $PATH. É possível fazer isso usando o comando setx no PowerShell:

      • setx PATH "$($env:path);$GOPATHbin"

      Isso permitirá que você execute qualquer programa que compilar ou baixar através das ferramentas Go - em qualquer lugar em seu sistema.

      Agora que você tem a raiz do espaço de trabalho criada e sua variável de ambiente $GOPATH definida, crie seus projetos futuros com a seguinte estrutura de diretório. Este exemplo supõe que esteja usando o como seu repositório:


      Se estivesse trabalhando no projeto, você o colocaria no seguinte diretório:


      Estruturar seus projetos dessa maneira irá torná-los disponíveis com a ferramenta go get. Isso também ajudará mais adiante com a legibilidade.

      É possível verificar isso usando o comando go get para buscar a biblioteca godo:

      • go get

      Nota: se não tiver o git instalado, o Windows abrirá uma caixa de diálogo perguntando se deseja instalá-lo. Clique em Yes para continuar e siga as instruções de instalação.

      É possível ver se ele baixou corretamente o pacote godo, listando o diretório:

      • ls $env:GOPATH/src/

      Você receberá um resultado semelhante a este:


      Directory: C:Userssammygosrcgithub.comdigitaloceangodo Mode LastWriteTime Length Name ---- ------------- ------ ---- d----- 4/10/2019 2:59 PM util -a---- 4/10/2019 2:59 PM 9 .gitignore -a---- 4/10/2019 2:59 PM 69 .travis.yml -a---- 4/10/2019 2:59 PM 1592 account.go -a---- 4/10/2019 2:59 PM 1679 account_test.go -rw-r--r-- 1 sammy staff 2892 Apr 5 15:56 -rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 . . . -a---- 4/10/2019 2:59 PM 5076 vpcs.go -a---- 4/10/2019 2:59 PM 4309 vpcs_test.go

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

      Passo 6 — Criando um programa simples

      Agora que você tem o espaço de trabalho em Go configurado, crie um programa “Hello, World!” simples. Isso garantirá que seu espaço de trabalho fique devidamente configurado, bem como dará a você a oportunidade de se familiarizar com o Go. Como está criando um único arquivo fonte em Go e não um projeto real, você não precisa estar em seu espaço de trabalho para fazer isso.

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

      Assim que o arquivo de texto abrir no nano, digite seu programa:


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

      Saia do nano, pressionando as teclas CTRL e X. Quando solicitado a salvar o arquivo, pressione Y e, então, ENTER.

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

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

      O programa hello.go que você acabou de criar deve fazer com que o PowerShell produza o seguinte resultado:


      Hello, World!

      Neste passo, você usou um programa básico para verificar se seu espaço de trabalho em Go foi configurado corretamente.


      Parabéns! Neste ponto, você tem um espaço de trabalho de programação em GO configurado em sua máquina local (com Windows) e pode começar um projeto de codificação!

      Source link