Go em projetos reais: 5 casos de empresas que vão te surpreender

Go em projetos reais: casos de empresas que reescreveram tudo em Go

Go (ou Golang) não é apenas uma linguagem da moda do Google, que todos elogiam pela velocidade e simplicidade. É uma ferramenta real que já salvou bilhões de dólares e a sanidade de milhares de desenvolvedores. Se você ainda pensa que Go é só sobre "Hello, World" e utilitários de linha de comando, este material vai virar sua visão de cabeça para baixo.

Vamos analisar cinco casos reais onde Go não foi apenas uma escolha, mas uma salvação. E sim, terá código, terá análise, terá conclusões. Vamos nessa.

Caso 1: Docker — como o Go revolucionou o mundo da conteinerização

Começamos com o exemplo mais famoso. Docker é, provavelmente, o projeto mais conhecido em Go. Quando Solomon Hykes lançou o Docker em 2013, ele escolheu Go não por acaso. O motivo? Compilação estática, goroutines nativas e ausência de uma máquina virtual pesada.

Docker é um exemplo clássico onde Go é ideal para programação de sistemas. Cada contêiner é um processo isolado, e Go permite gerenciá-los com sobrecarga mínima.

Aqui está como se parece a lógica simplificada de iniciar um contêiner em Go:

package main\n\nimport (\n    "fmt"\n    "os/exec"\n    "syscall"\n)\n\nfunc runContainer(image string, cmd string) error {\n    // Criamos um novo processo com isolamento\n    child := exec.Command("/proc/self/exe", append([]string{"child"}, cmd...)...)\n    child.SysProcAttr = &syscall.SysProcAttr{\n        Cloneflags: syscall.CLONE_NEWNS |\n            syscall.CLONE_NEWUTS |\n            syscall.CLONE_NEWPID,\n    }\n    child.Stdin = os.Stdin\n    child.Stdout = os.Stdout\n    child.Stderr = os.Stderr\n\n    if err := child.Run(); err != nil {\n        return fmt.Errorf("falha ao iniciar o contêiner: %w", err)\n    }\n    return nil\n}\n\nfunc main() {\n    // Exemplo: iniciar contêiner com bash\n    if err := runContainer("ubuntu:latest", "/bin/bash"); err != nil {\n        fmt.Println("Erro:", err)\n    }\n}

Observe: syscall.CLONE_NEWNS e CLONE_NEWPID são chamadas diretas de sistema do Linux. Go permite trabalhar com elas nativamente, sem wrappers. É exatamente disso que o Docker precisa.

Conclusão para você: Se seu projeto envolve chamadas de sistema, conteinerização ou gerenciamento de recursos de baixo nível — Go é sua escolha. Nenhuma outra linguagem oferece acesso tão direto ao kernel com tanta simplicidade.

Caso 2: Kubernetes — orquestração na velocidade do Go

Se Docker é a base, Kubernetes é o cérebro. E sim, ele também é escrito em Go. Kubernetes gerencia milhares de contêineres, distribui carga, reinicia pods com falha e faz isso com um desempenho difícil de imaginar em Python ou Ruby.

O segredo do Kubernetes está nas goroutines. Cada controlador, cada scheduler, cada servidor da API funciona como um conjunto de goroutines leves. Isso permite processar milhares de requisições por segundo sem bloqueios.

Aqui está um exemplo de como um controlador simples é implementado no Kubernetes, monitorando o estado dos pods:

package main\n\nimport (\n    "context"\n    "fmt"\n    "time"\n    \n    "k8s.io/client-go/kubernetes"\n    "k8s.io/client-go/tools/clientcmd"\n)\n\nfunc watchPods(clientset *kubernetes.Clientset) {\n    watcher, err := clientset.CoreV1().Pods("default").Watch(context.TODO())\n    if err != nil {\n        panic(err)\n    }\n    \n    for event := range watcher.ResultChan() {\n        pod := event.Object.(*v1.Pod)\n        fmt.Printf("Evento: %s - Pod: %s (Fase: %s)\\n", \n            event.Type, pod.Name, pod.Status.Phase)\n        \n        // Lógica de reinicialização de pods com falha\n        if pod.Status.Phase == v1.PodFailed {\n            fmt.Printf("Pod %s falhou, acionando reinicialização...\\n", pod.Name)\n            // Aqui vai a lógica de reinicialização\n        }\n    }\n}\n\nfunc main() {\n    config, _ := clientcmd.BuildConfigFromFlags("", "")\n    clientset, _ := kubernetes.NewFor