O que é Go?

Portuguese (Português) translation by Claudemiro Feitosa (you can also view the original English article)

Go é uma linguagem de programação de código aberto desenvolvida pelo Google e projetada para ajudar a construir sistemas simples e reusáveis. O ponto forte do Go são seus mecanismos de concorrência os quais tornam mais simples escrever software, para aproveitar as arquiteturas de múltiplos núcleos.

É compilada, fortemente - estáticamente tipada, concorrente e é uma linguagem com coletor de lixo.

É bem interessante, uma linguagem moderna por conta das escolhas que foram feitas durante o seu projeto. Por exemplo, o sistema de tipos, embora Go possua métodos e também um estilo Orientado a Objetos de programação, não há hierarquia de tipos. A única forma de alcançar isto é através de interfaces.

Como Go se destaca dos outros.

Deve-se ler a especificação da linguagem para se obter um melhor entendimento do projeto e elementos da linguagem. É realmente concisa e ajuda a entender alguns detalhes interessantes. A forma que Go se destaca das outras linguagens de programação típicas, é que ela possui características que outras linguagens orientadas a objetos não possuem:

Não há herança de tipos
Não há sobrecarga de métodos e operadores.
Primitivas de concorrência embutidas na linguagem, as quais realmente a separa da multidão. Ela compartilha memória comunicando-se e não o contrário.
Um kit de ferramentas que usa modelos tradicionais de compilação e ligação para gerar binários sem dependências externas.
Dicionários fazem parte da linguagem.

Organização de código

Os códigos em Go são mantidos em áreas de trabalho. É apenas uma hierarquia, como segue:

src - contém os arquivos de código fonte em Go como pacotes
pkg - contém objetos de pacote
bin - contém executáveis

As ferramentas Go compilam os pacotes de código e instala os binários nos diretórios bin e pkg respectivamente.

Uma Simples Aplicação Web Usando Go

Vamos construir um site estático e depois melhora-lo para que ele se comporte muito mais como um site dinâmico, baseado na entrada do usuário.

O Site Estático

A estrutura de código para o site estático se parece com:

Então, essencialmente você vai criar uma estrutura similar a da imagem acima ou como é mostrado no repositório. Esta estrutura do repositório pode por si mesmo ficar em uma área de trabalho. Leia sobre a Estrutura de código em Go para mais informações.

Agora o que nós queremos é servir um arquivo HTML que está no diretório public.

O conteúdo do arquivo index.html é o seguinte:

<!DOCTYPE html>
 <html>
   <head>
     <title>Static site using Go</title>
     <link rel="stylesheet" type="text/css" href="stylesheets/gostatic.css">
   </head>


   &lt;body&gt;
     &lt;h1&gt;Developing Website using Go&lt;/h1&gt;
     &lt;p&gt;I am a static page, being served to you with the help of Go lang.&lt;/p&gt;
   &lt;/body&gt;
 </html>

E aqui está o programa Go para servir os arquivos estáticos da pasta public:

package main

import (
  "net/http"
)

func main() {
  fs := http.FileServer(http.Dir("public"))
  http.ListenAndServe(":8080", fs)
}

Deixe-me explicar:

net/http - este pacote provê implementações um cliente e servidor HTTP.
FileServer - está função retorna um handler que serve as requisições HTTP com o conteúdo do sistema de arquivos.

É só isso. Muito simples e direto ao ponto. Você pode rodar este código usando: go run gostatic.go

Uma solução melhor

No entanto, esta solução não separa claramente o roteamento de servir e consequentemente, uma melhor solução seria perto das linhas a seguir:

package main

import (
 "net/http"
 "log"
)

func main() {
  fs := http.FileServer(http.Dir("public"))
  http.Handle("/", fs)
  log.Println("Listening...")
  err := http.ListenAndServe(":8080", nil)
  if err != nil {
    log.Fatal("ListenAndServe: ", err)
 }
}

ListenAndServe inicia um servidor HTTP e um dado endereço TCP e então chama Serve com um handler. Este handler é tipicamente nil, então o roteador padrão (No caso do Go o DefaultServerMux pode assumir).

Agora no que diz respeito ao DefaultServerMux - Vamos fazer um tour para entender como Go processa requisições HTTP. Ele o faz com ajuda de duas coisas primárias.

ServerMuxes - (Roteador) é um multiplexador - essencialmente um roteador HTTP, que compara as requisições que chegam a lista definida e então chama o handler associado.
Handlers - Este são responsáveis por 'manipular' a requisição, como responder com os cabeçalhos, corpo, etc apropriados. Qualquer objeto implementa a interface Handler pode agir como um.

Vá em frente e rode a aplicação de exemplo como antes e você deve ver alguma saída!

Sites dinâmicos - Adicionado um Timestamp em cada atualização.

Próximo, vamos escrever uma aplicação que exibe a hora atual, implicando que em cada atualização você terá uma saída diferente. P código Go se parece com o seguinte:

package main


 import (
   "fmt"
   "net/http"
   "time"
 )


 func main() {
     http.HandleFunc("/", handler)
     log.Println("listening...")
     err := http.ListenAndServe(":8080", nil)
     if err != nil {
         panic(err)
     }
 }


 func handler(w http.ResponseWriter, r *http.Request) {
     fmt.Fprintf(w, "Hello. The time is : " + time.Now().Format(time.RFC850))
 }

Aqui nós importamos fmt para trabalhar com primitivas de impressão. O fmt implementa funções formatadas de E/S com uma interface similar a stdio do C.

Nós também fizemos uso de HandleFunc que registra o caminho da URL com a função handler no DefaultServerMux. A função handler é do tipo http.HandlerFunc Ela leva como argumentos http.ResponseWriter e http.Request. Pessoas familiarizadas com Java servlets irão lembrar disto!

Para imprimir a hora, nós importaremos 'time' da biblioteca padrão e usaremos para responder no objeto response writer. Em escrever no objeto http.ResponseWriter nós enviaremos a resposta ao cliente.

http.Request é uma estrutura que representa a requisição HTTP e consequentemente possui todos os dados da requisição. Para acessar o caminho da URL nós fazemos r.URL.path.

Quando você rodar o programa e então acessar localhost:8080 você deve ser a hora atual a cada atualização.

Aceitando Entrada do Usuário

Agora vamos escrever uma aplicação que aceita um username na página inicial e então quando o formulário é enviado, ele cumprimenta o usuário na próxima página.

Aqui nossa estrutura de código:

Primeiramente vamos criar o arquivo HTML contendo o formulário dentro do diretório public.

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Go Greeter</title>
</head>
<body>
  <h1>Go Greeter</h1>
  <form action="/greet" method="post" accept-charset="utf-8">
    <input type="text" name="username" id="username" value="Enter username...">
    <input type="submit" value="Greet me!">
  </form>
</body>
</html>

Este formulário, quando enviado, irá redirecionar para /greet. Vamos também escrever o conteúdo do arquivo greet.html dentro do diretório public, o qual nós vamos renderizar quando a requisição for enviada para /greet.

<!DOCTYPE html>
 <html>
  <head>
    <meta charset="utf-8">
    <title>Go Greeter</title>
  </head>
  <body>
    <pre>Hello {{.}}</pre>
  </body>
</html>

O código Go é o seguinte:

package main


import (
  "log"
  "net/http"
  "html/template"
)


func main() {
  http.HandleFunc("/", root)
  http.HandleFunc("/greet", greeter)
  log.Println("Listening...")
  err := http.ListenAndServe(":8080", nil)
  if err != nil {
    log.Fatal("ListenAndServe: ", err)
   }
}


func root(w http.ResponseWriter, r *http.Request) {
  t, _ := template.ParseFiles("public/index.html")
  t.Execute(w, nil)
}


func greeter(w http.ResponseWriter, r *http.Request) {
  username := r.FormValue("username")
  t, _ := template.ParseFiles("public/greeter.html")
  err := t.Execute(w, username)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
  }
}

Nós usamos html/template para manter o código HTML nos templates e então usamos para renderizar, na requisição

Há estes caracteres estranos {{.}} no arquivo greeter.html. O pacote html/template assume que sempre é produzido texto comum. É adicionado caracteres de escape sempre que necessário para embutir as strings de forma segura no contexto correto. Quando um dado valor não está em texto puro, nós podemos ter certeza que não foi escapado apenas especificando o seu tipo. Então essencialmente, Hey, {{.}}! pode ser chamado usando tmpl.Execute(out, HTML('Nishant')) para produzir Hey, Nishant!. Vá em frente, tente!

Já que a aplicação básica está funcionando, nós podemos finalmente fazer deploy no Heroku.

Fazendo Deploy no Heroku

Assim que você tiver o heroku-toolbelt corretamente configurado e um repositório gerenciado via Git, nós poderemos fazer deploy com estas linhas.

A única alteração que precisamos fazer no código para deploy no Heroku, é alterar a linha onde nós escutamos em uma porta especifica.

Altere:

http.ListenAndServe(":8080",...)

para:

http.ListenAndServe(":"+os.Getenv("PORT"),....

Configuração Heroku

Para que podemos fazer deploy no Heroku, você irá precisar de uma conta no Heroku. Você também precisa de um cliente de linha de comando do Heroku. Obtenha instalando o Heroku Toolbelt se necessário.

Uma vez instalado, faça login usando sua conta Heroku com o comando heroku login, e então faça upload da sua chave SSH. Com estas coisas configuradas, você deve estar pronto para fazer deploy no Heroku.

Fazendo deploy da Aplicação

Para fazer deploy no Heroku, nós vamos precisar que a aplicaçõ esteja em um repositório Git.

git init .
git add -A .
git commit -m 'first heroku go app'

Nós também precisaremos de um Procfile para dizer ao Heroku que o comando precisa ser executado para rodar nossa aplicação.

echo 'web: gogreeter' > Procfile

Go e suas dependências são gerenciadas pelo Heroku com ajuda do pacote Godep.

Instale Godep e salve suas dependêndias usando o seguinte comando:

go get github.com/kr/godep
godep save

E adicione estes novos arquivos ao Git:

git add -A .
git commit -m 'godep'

Fincalmente, crie uma aplicação no Heroku. Pode ser feito assim:

heroku create -b https://github.com/kr/heroku-buildpack-go.git

Isto deve adicionar um repositório remoto na sua aplicação com o nome heroku. Agora você está pronto para fazer deploy! Rode o seguinte:

git push heroku master

Após os comandos acima estiverem completados, sua aplicação deve estar rodando!

Vá em frente e visite a URL usando o comando heroku open ou acessando diretamente a URL da sua aplicação que você ver no console.

É isso. Agora você tem uma aplicação em Go rodando no Heroku!

Sumário

Neste tutorial nós aprendemos quão simples é desenvolver uma aplicação web em Go e também a fazer deploy da mesma no Heroku. Atualmente, desenvolvimento web é largamente dependente dos frameworks que outros usam. Para explorar algumas destas opções, você definitivamente deveria alguns destes projetos.

Hugo
Martini
Revel
Gorilla web toolkit
Hastie - Gerador de sites estáticos em Go

Seja o primeiro a saber sobre novas traduções–siga @tutsplus_pt no Twitter!