Golang, ou apenas Go, tornou-se conhecido como a linguagem Go Gopher. Se você ainda não entende por que o esquilo pode encontrar uma história surpreendente do mascote neste artigo. Bem, vamos começar do início: Golang se tornou conhecido como uma das linguagens de programação mais produtivas que existem. Ao contrário de linguagens tradicionais como Java ou Python, Go atinge um equilíbrio único entre código fácil de escrever e execução rápida, acelerando o desenvolvimento e reduzindo o tempo de depuração e teste. Este artigo examinará um exemplo real de uso de goroutines e contexto em um projeto que interage com um microsserviço API REST lento e instável.

A tarefa
Vamos imaginar que você acabou de ingressar na equipe e o líder da equipe pede que você vincule um novo microsserviço escrito em Golang (por exemplo, o gerenciador de risco) ao microsserviço do usuário exposto por meio da API REST.

O problema
O gestor de risco precisa interagir com uma API REST que pode ser lenta e instável, exigindo que tratemos tais solicitações com cuidado. Usarei goroutines para solicitações HTTP assíncronas e contexto para gerenciar tempos limite de solicitação e tratamento de erros.

A solução

O uso de goroutines e contexto em Golang permite o gerenciamento eficiente de tarefas simultâneas e o manuseio de APIs externas lentas ou instáveis.

O primeiro passo para interpretá-lo em um código é criar a API, usei o serviço shareware https://mockapi.io/ É conveniente gerar um REST API com um conjunto básico de entidades, como usuários.

Digamos que alguém deu o melhor de si e sua empresa tem um serviço interno que lista os usuários. Nossa tarefa é reutilizar a lista de usuários no novo gerenciador de risco (a estrutura de dados do usuário satisfaz o contrato descrito por mockapi.io). O código abaixo faz uma solicitação, processa o corpo e produz uma lista de usuários ou o erro correspondente.

type User struct {
    CreatedAt string
    Name      string
    Avatar    string
    Id        string
}

// Original slow request
func fetchUsers(ctx context.Context) (*[]User, error) {
    resp, err := http.Get("https://.mockapi.io/api/v1/users")
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("failed to fetch users: %s", resp.Status)
    }

    var users []User
    if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
        return nil, err
    }

    return &users, nil
}

Para controlar a operação, usarei o contexto pai superior para todos os outros contextos - context.Background. Complementarei este contexto com novos dados, neste caso o tempo limite - context.WithTimeout, que definirei como 2 segundos. Você pode ler mais sobre como trabalhar com contextos em Go neste artigo.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

usersChan := make(chan *[]User)
errChan := make(chan error)

go func() {
    users, err := fetchUsers(ctx)
    if err != nil {
        errChan 



No exemplo, utilizo dois canais - usersChan para registrar o resultado recebido de nosso serviço interno, e o segundo canal errChan - para registrar o erro.

Se a resposta de uma API lenta não chegar em 2 segundos, detectamos um erro e damos a oportunidade de processá-lo corretamente em uma camada externa.

Neste exemplo prático com o gerenciador de risco, goroutines permitiram solicitações HTTP assíncronas, enquanto o contexto garantiu o tratamento de tempo limite, o que é fundamental para a construção de microsserviços confiáveis ​​e resilientes.

P.S.


Este artigo é destinado a desenvolvedores iniciantes que possuem conhecimentos básicos, mas pouca ideia de onde podem aplicar seus conhecimentos. Ficarei feliz em receber seus comentários e responder às suas perguntas.

Um exemplo prático e diversas outras implementações das coisas mais básicas da linguagem Go podem ser encontradas no meu GitHub, no link