One place for hosting & domains

      Ambiente

      Como Instalar o Django e Configurar um Ambiente de Desenvolvimento no Ubuntu 20.04


      Introdução

      O Django é um framework web de código aberto, escrito em Python com seus princípios fundamentais sendo escalabilidade, reusabilidade e desenvolvimento rápido. Ele também é conhecido por sua consistência a nível de framework e pelo baixo acoplamento, permitindo que os componentes sejam independentes uns dos outros.

      Neste tutorial, vamos configurar um ambiente Django para fins de desenvolvimento em um servidor Ubuntu 20.04. Para um site ativo, você terá considerações adicionais, incluindo a conexão a um banco de dados, configuração de um nome de domínio e adição de camadas de segurança. Temos uma variedade de tutoriais de Django que podem ajudar você enquanto você cria sob nossa tag Django.

      Pré-requisitos

      Para completar este tutorial, você irá precisar de:

      Passo 1 — Instalando o Django

      Há várias maneiras de instalar o Django, usando o gerenciador de pacotes Python pip dentro de um ambiente virtual.

      Estando no diretório home do servidor, vamos criar o diretório que conterá nossa aplicação Django. Execute o seguinte comando para criar um diretório chamado django-apps, ou outro nome de sua escolha. Em seguida, vá até o diretório.

      • mkdir django-apps
      • cd django-apps

      Estando dentro do diretório django-apps, crie seu ambiente virtual. Vamos chamá-lo de generic env, mas você deve usar um nome que é significativo para você e seu projeto.

      Agora, ative o ambiente virtual com o seguinte comando:

      Você saberá que ele está ativado assim que o prefixo for alterado para (env), que será parecido com o seguinte, dependendo de qual diretório você está:

      Dentro do ambiente, instale o pacote Django usando o pip. A instalação do Django nos permite criar e executar aplicações Django.

      Uma vez instalado, verifique sua instalação do Django executando uma verificação de versão:

      Esta, ou algo parecido, será a saída resultante:

      Output

      3.0.6

      Com o Django instalado em seu servidor, podemos seguir em frente para criar um projeto de teste para garantir que tudo esteja funcionando corretamente. Criaremos uma aplicação web esqueleto.

      Passo 2 — Ajustando as Configurações de Firewall

      Se você seguiu nosso tutorial de configuração inicial do servidor ou tiver um firewall em execução em seu servidor, vamos precisar abrir a porta que vamos usar no firewall do nosso servidor. Para o firewall UFW, você pode abrir a porta com o seguinte comando:

      Se você estiver usando o Firewall da DigitalOcean, você pode selecionar HTTP das regras de entrada. Você pode ler mais sobre o Firewall da DigitalOcean e criar regras para ele modificando as regras de entrada.ou inbound rules

      Passo 3 — Iniciando o Projeto

      Agora, podemos gerar uma aplicação usando o django-admin, um utilitário de linha de comando para tarefas de administração em Python. Em seguida, podemos usar o comando startproject para criar a estrutura de diretórios do projeto para nosso site de teste.

      Estando no diretório django-apps, execute o seguinte comando:

      • django-admin startproject testsite

      Nota: executar o comando django-admin startproject <projectname> irá nomear tanto o diretório do projeto quanto o pacote de projeto como <projectname> e criar o projeto no diretório em que o comando foi executado. Se o parâmetro opcional <destination> for fornecido, o Django utilizará o diretório de destino fornecido como diretório do projeto e criará o manage.py e o pacote do projeto dentro dele.

      Agora podemos ver quais arquivos de projeto foram criados. Navegue até o diretório testsite , em seguida liste o conteúdo desse diretório para ver quais arquivos foram criados:

      Output

      manage.py testsite

      Você notará a saída que mostra que este diretório contém um arquivo chamado manage.py e uma pasta chamada testsite. O arquivo manage.py é similar ao django-admin e coloca o pacote do projeto no sys.path. Ele também define a variável de ambiente DJANGO_SETTINGS_MODULE para apontar para o arquivo settings.py do seu projeto.

      Você pode ver o script manage.py em seu terminal executando o comando less dessa forma:

      Quando você terminar de ler o script, pressione q para parar de visualizar o arquivo.

      Agora, vá até o diretório testsite para visualizar os outros arquivos que foram criados:

      Em seguida, execute o seguinte comando para listar o conteúdo do diretório:

      Você verá quatro arquivos:

      Output

      __init__.py asgi.py settings.py urls.py wsgi.py

      Vamos analisar o que são esses arquivos:

      • __init__.py atua como o entry point para seu projeto Python.
      • O asgi.py contém a configuração para o deployment opcional na Interface de Gateway de Servidor Assíncrono ou ASGI, que fornece um padrão para aplicativos que são síncronos e assíncronos, e é considerado como um sucessor do WSGI (veja abaixo).
      • settings.py descreve a configuração de sua instalação do Django e permite que o Django saiba quais configurações estão disponíveis.
      • urls.py contém uma lista de urlpatterns, que roteia e mapeia URLs para suas views
      • wsgi.py contém a configuração para a Interface de Gateway do Servidor Web ou WSGI, que fornece um padrão para aplicativos Python síncronos.

      Nota: embora os arquivos padrão sejam gerados, você ainda tem a capacidade de ajustar os arquivos asgi.py ou wsgi.py, a qualquer momento para os adequar às necessidades da implantação.

      Passo 4 — Configurando o Django

      Agora, podemos iniciar o servidor e visualizar o site em um host e porta designados executando o comando runserver.

      Vamos precisar adicionar o endereço IP do seu servidor à lista ALLOWED_HOSTS no arquivo settings.py, localizado em ~/test_django_app/testsite/testsite/.

      Como indicado em Django docs, a variável ALLOWED_HOSTS contém “uma lista de strings representando os nomes de host/domínio que este site de Django pode servir. Esta é uma medida de segurança para evitar ataques de cabeçalhos de Host HTTP, que são possíveis mesmo em muitas configurações de servidor web aparentemente seguras.

      Você pode usar seu editor de texto favorito para adicionar seu endereço IP. Por exemplo, se você estiver usando o nano, execute o seguinte comando:

      • nano ~/django-apps/testsite/testsite/settings.py

      Assim que executar o comando, você irá querer acessar a seção Allowed Hosts do documento e adicionar o endereço IP do seu servidor dentro de colchetes entre aspas simples ou duplas.

      settings.py

      """
      Django settings for testsite project.
      
      Generated by 'django-admin startproject' using Django 2.0.
      ...
      """
      ...
      # SECURITY WARNING: don't run with debug turned on in production!
      DEBUG = True
      
      # Edit the line below with your server IP address
      ALLOWED_HOSTS = ['your-server-ip']
      ...
      

      Você pode salvar a alteração e sair do nano mantendo pressionadas as teclas CTRL + x e, em seguida, pressionando a tecla y. Em seguida, vamos seguir em frente para acessar nosso app web através de um navegador.

      Passo 5 — Acessando o App Web do Django

      Com nossa configuração concluída, certifique-se de voltar para o diretório onde o manage.py está localizado:

      • cd ~/django-apps/testsite/

      Agora, execute o seguinte comando substituindo o texto your-server-ip pelo IP do seu servidor:

      • python manage.py runserver 0.0.0.0:8000

      Por fim, você pode acessar o link abaixo para ver como seu site esqueleto se apresenta, substituindo novamente o texto destacado pelo IP real do seu servidor:

      http://your-server-ip:8000/
      

      Assim que a página carregar, você verá o seguinte:

      Django Default Page

      Isso confirma que o Django foi instalado corretamente e o projeto de teste está funcionando corretamente.

      Para acessar a interface de administração, adicione /admin/ ao final do seu URL:

      http://your_server_ip:8000/admin/
      

      Isso o levará a uma tela de login:

      Django admin login

      Se você digitar o nome de usuário e senha do admin que você acabou de criar, você terá acesso à seção de administração principal do site:

      Django admin page

      Para mais informações sobre como trabalhar com a interface de administração do Django, consulte “Como Habilitar e Conectar a Interface Admin do Django”.

      Quando você terminar de testar seu app, você pode pressionar CTRL + C para parar o comando runserver. Isso o retornará para seu ambiente de programação.

      Quando estiver pronto para deixar seu ambiente Python, você pode executar o comando deactivate:

      A desativação do seu ambiente de programação o levará de volta ao prompt de comando do terminal.

      Conclusão

      Neste tutorial, você instalou o Django com sucesso e configurou um ambiente de desenvolvimento para começar a trabalhar em seu app Django.

      Agora você tem a base necessária para começar a desenvolver aplicações Web no Django.



      Source link

      Como instalar o Python 3 e configurar um ambiente de programação no CentOS 8


      Introdução

      O Python é uma linguagem de programação versátil e pode ser utilizada em vários projetos diferentes de programação. Inspirado pelo grupo de comédia britânico Monty Python, a equipe de desenvolvedores do Python queria torná-lo uma linguagem que fosse divertida de usar. O Python é uma linguagem com diversas aplicações que cresce em popularidade a cada dia, e é uma ótima escolha tanto para desenvolvedores iniciantes quanto experientes.

      Este tutorial o guiará na instalação do Python 3 em um servidor CentOS 8 em nuvem e na configuração do ambiente de programação através de linhas de comando.

      Pré-requisitos

      Será necessário um servidor CentOS 8 com uma conta de superusuário não root.

      Para configurar isso, você pode seguir nosso Guia de configuração inicial de servidor para o CentOS 8.

      Passo 1 — Preparando o sistema

      Antes de começar a instalação, atualize os aplicativos padrão do sistema para suas versões mais recentes.

      Utilizaremos a ferramenta de gerenciamento de pacotes de código aberto DNF, que significa Dandified YUM, a próxima geração da versão Yellowdog Updater, Modified (ou seja, yum). O DNF é o gerenciador de pacotes padrão nos sistemas Linux baseados em Red Hat, como o CentOS. Ele permitirá que você instale, atualize e remova os pacotes de software em seu servidor.

      Primeiro, vamos verificar se nosso gerenciador de pacotes está atualizado executando este comando:

      O sinalizador -y é usado para alertar o sistema que estamos cientes das alterações que estamos fazendo, impedindo que o terminal nos envie solicitações de confirmação.

      Assim que tudo estiver instalado, nossa configuração estará pronta e poderemos seguir para a instalação do Python 3.

      Passo 2 — Instalando e configurando o Python 3

      O CentOS é um derivado do RHEL (Red Hat Enterprise Linux), que tem a estabilidade como seu foco principal. Por este motivo, é mais comum encontrar versões testadas e estáveis dos aplicativos no sistema e nos pacotes para download. Portanto, ao utilizar o gerenciador de pacotes CentOS você se deparará com versões mais antigas do Python, e não com a mais recente.

      • sudo dnf install python3 -y

      Quando este processo terminar, verificaremos se a instalação foi bem-sucedida, verificando o número da versão dela com o comando python3:

      Com uma versão do Python 3 instalada com sucesso, receberemos a seguinte saída:

      Output

      Python 3.6.8

      Em seguida, instalaremos as ferramentas de desenvolvimento do CentOS, que são utilizadas para desenvolver e compilar o software a partir do código-fonte:

      • sudo dnf -y groupinstall development

      Com as ferramentas instaladas, seguiremos para a próxima seção, na qual vamos analisar como configurar os projetos de desenvolvimento do Python.

      Passo 3 — Configurando um ambiente virtual

      Com Python instalado e nosso sistema configurado, vamos criar nosso ambiente de programação com o venv.

      Os ambientes Virtuais permitem que você tenha um espaço isolado no seu computador para projetos Python, garantindo que cada um dos seus projetos possa ter seus próprios conjuntos de dependências que não perturbarão nenhum dos seus outros projetos.

      A configuração de um ambiente de programação nos permite ter mais controle sobre nossos projetos em Python, bem como sobre diferentes pacotes e versões. Isso é especialmente importante durante o trabalho com pacotes de terceiros.

      É possível configurar quantos ambientes de programação Python você quiser. Essencialmente, cada ambiente é um diretório ou uma pasta em seu servidor, e cada um deles contém alguns scripts para configurá-los como um ambiente.

      Escolha o diretório no qual você gostaria de colocar seus ambientes de programação Python, ou crie um novo diretório com o mkdir, desta maneira:

      • mkdir environments
      • cd environments

      Assim que estiver no diretório onde você quer que os ambientes fiquem, crie um ambiente executando o seguinte comando: Use um nome de ambiente que faça algum sentido para você. Aqui o chamaremos de my_env.

      Neste caso, o ambiente é o my_env, e este novo diretório contém alguns itens que serão exibidos se aplicarmos o comando ls ao diretório:

      Output

      bin include lib lib64 pyvenv.cfg

      Juntos, estes arquivos atuam para isolar seu trabalho Python do contexto mais amplo de sua máquina local, para que os arquivos do sistema e os arquivos do projeto não se misturem. Esta é uma boa prática para o controle de versão e para garantir que cada um dos seus projetos tenha acesso aos pacotes específicos de que necessita.

      Será necessário ativar o ambiente para poder usá-lo. Digite o seguinte comando para chamar o script activate no diretório bin:

      • source my_env/bin/activate

      Seu prompt de comando estará prefixado com o nome do seu ambiente, neste caso ele se chama my_env:

      Esse prefixo nos permite saber que o ambiente my_env está ativo no momento, o que significa que quando criarmos programas aqui, eles somente usarão as configurações e pacotes específicos deste ambiente.

      O gerenciador de pacotes Python pip já está instalado. Utilizaremos o pip, uma ferramenta do Python usada para instalar e gerenciar os pacotes de programação que desejamos usar em nossos projetos de desenvolvimento. Você pode instalar os pacotes Python digitando:

      • sudo pip install package_name

      Aqui, o package_name pode se referir a qualquer pacote ou biblioteca Python, tais como o Django para o desenvolvimento Web ou o NumPy para a computação científica. Se você quiser instalar o NumPy, use o comando pip install numpy.

      Nota: dentro do ambiente virtual, você pode usar o comando python em vez do python3, e o pip em vez do pip3. Se você usar o Python 3 ou o pip3 em sua máquina fora de um ambiente, terá que utilizar os comandos python3 e pip3 exclusivamente.

      Após seguir esses passos, seu ambiente virtual estará pronto para usar.

      Passo 4 — Criando um “Hello, World!”

      Agora que temos nosso ambiente virtual configurado, criaremos o programa tradicional “Hello, World! para testar nossa instalação. Isso confirmará que nosso ambiente está funcionando, e nos dará a oportunidade de nos familiarizarmos com o Python se ainda não estivermos.

      Para fazer isso, vamos abrir um editor de texto de linha de comando, como o vi, e criar um novo arquivo:

      Assim que arquivo de texto abrir em nossa janela de terminal, teremos que digitar i para entrar no modo de inserção. Em seguida, vamos escrever nosso primeiro programa:

      print("Hello, World!")
      

      Pressione ESC para sair do modo de inserção. Agora, digite :x e, depois, ENTER para salvar e sair do arquivo.

      Estamos prontos para executar nosso programa:

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

      Output

      Hello, World!

      Para sair do ambiente, digite o comando deactivate e você voltará para seu diretório original.

      Conclusão

      Parabéns! Neste ponto, você tem um ambiente de programação Python 3 configurado em seu servidor CentOS8 e já pode começar um projeto de programação!

      Com sua máquina pronta para desenvolver softwares, você pode aprender mais sobre a programação em Python seguindo nossa série Como programar em Python, ou baixando gratuitamente o eBook Como programar em Python.

      Para se aprofundar em projetos de machine learning, consulte nosso eBook Projetos de machine learning em Python.



      Source link

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


      Introdução

      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.

      Pré-requisitos

      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:

      Output

      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("https://chocolatey.org/install.ps1")

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

      • iwr https://chocolatey.org/install.ps1 -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 golang.org.

      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:

      Output

      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:

      Output

      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 github.com ou golang.org quando seu programa importar bibliotecas de terceiros. Se estiver usando um repositório de códigos como o github.com, 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 github.com/digitalocean/godo.

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

      .
      ├── bin
      │   ├── buffalo                                      # command executable
      │   ├── dlv                                          # command executable
      │   └── packr                                        # command executable
      └── src
          └── github.com
              └── 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:

      Output

      C:Userssammygo

      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 github.com como seu repositório:

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

      Se estivesse trabalhando no projeto https://github.com/digitalocean/godo, você o colocaria no seguinte diretório:

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

      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 github.com/digitalocean/godo

      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/github.com/digitalocean/godo

      Você receberá um resultado semelhante a este:

      Output

      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 CHANGELOG.md -rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 CONTRIBUTING.md . . . -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:

      hello.go

      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:

      Output

      Hello, World!

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

      Conclusão

      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