Início rápido: Usar o Cache do Azure para Redis com Go

2025-05-18
Aplica-se a: ✅ Azure Cache for Redis

Neste artigo, você aprenderá a criar uma API REST em Go que armazenará e recuperará informações de usuário apoiadas por uma estrutura de dados HASH no Cache do Azure para Redis.

Se você quiser pular diretamente para o código, confira o Guia de início rápido do Go no GitHub.

Pré-requisitos

Assinatura do Azure - criar uma gratuitamente
Go (preferencialmente versão 1.13 ou superior)
Git
Um cliente HTTP como curl

Criar uma instância de Cache do Azure para Redis

No portal do Azure, pesquise e selecione o Cache do Azure para Redis.
Na página Cache do Azure para Redis , selecione Criar>Cache do Azure para Redis.
Na guia Noções básicas da página Novo Cache Redis , defina as seguintes configurações:
- Assinatura: selecione a assinatura a ser utilizada.
- Grupo de recursos: selecione um grupo de recursos ou selecione Criar novo e insira um novo nome de grupo de recursos. Colocar todos os recursos do aplicativo no mesmo grupo de recursos permite que você os gerencie ou exclua facilmente.
- Nome: insira um nome de cache exclusivo na região. O nome deve:
  - Seja uma cadeia de caracteres de 1 a 63 caracteres.
  - Contêm apenas números, letras e hifens.
  - Inicie e termine com um número ou uma letra.
  - Não deve conter hifens consecutivos.
- Região: selecione uma região do Azure perto de outros serviços que usam seu cache.
- SKU de cache: selecione um SKU para determinar os tamanhos, o desempenho e os recursos disponíveis para o cache.
- Tamanho do cache: selecione um tamanho de cache. Para obter mais informações, consulte Visão geral do Cache do Azure para Redis.
Selecione a guia Rede ou selecione Avançar: Rede.
Na guia Rede, selecione um método de conectividade a ser usado para o cache. O Ponto de Extremidade Privado é recomendado para segurança. Se você selecionar Ponto de Extremidade Privado, selecione Adicionar Ponto de Extremidade Privado e crie o ponto de extremidade privado.
Selecione a guia Avançado ou selecione Avançar: Avançado.
No painel Avançado , configure as seguintes opções:
- Selecione Autenticação do Microsoft Entra ou Autenticação por Chaves de Acesso. A Autenticação do Microsoft Entra está habilitada por padrão.
- Escolha se deseja habilitar a porta não TLS.
- Para um cache Premium, você pode configurar ou desabilitar zonas de disponibilidade. Não é possível desabilitar zonas de disponibilidade após a criação do cache. Para um cache Standard, as zonas de disponibilidade são alocadas automaticamente. As zonas de disponibilidade não estão disponíveis para o SKU Básico.
- Para um cache Premium, defina as configurações para contagem de réplicas, clustering e contagem de fragmentos, identidade gerenciada atribuída pelo sistema e persistência de dados.
A imagem a seguir mostra a guia Avançado para o SKU Standard.

Importante

Use o ID do Microsoft Entra com identidades gerenciadas para autorizar solicitações contra o cache, se possível. A autorização usando a ID do Microsoft Entra e a identidade gerenciada fornece melhor segurança e é mais fácil de usar do que a autorização de chave de acesso compartilhado. Para obter mais informações sobre como usar identidades gerenciadas com seu cache, consulte Usar a ID do Microsoft Entra para autenticação de cache.
Opcionalmente, selecione a guia Marcas ou selecione Avançar: Marcas e insira nomes e valores de marca para categorizar os recursos de cache.
Selecione Examinar + criar e, depois que a validação for aprovada, selecione Criar.

A nova implantação de cache leva vários minutos. Você pode monitorar o progresso da implantação na página portal do Cache do Azure para Redis. Quando o status do cache é exibido em execução, o cache está pronto para ser usado.

Recuperar o nome de host, as portas e as chaves de acesso do portal do Azure

Para conectar seu servidor do Cache do Azure para Redis, o cliente de cache precisa do nome do host, das portas e de uma chave para o cache. Alguns clientes podem se referir a esses itens por nomes um pouco diferentes. Você pode obter o nome do host, as portas e as chaves do portal do Azure.

Para obter o nome do host e as portas do cache, selecione Visão geral no menu Recurso. O nome do host está no formato <DNS name>.redis.cache.windows.net.
Para obter as chaves de acesso, selecione Autenticação no menu Recurso. Em seguida, selecione a guia Chaves de acesso.

Examinar o código (opcional)

Se você estiver interessado em saber como o código funciona, poderá examinar os trechos de código a seguir. Caso contrário, fique à vontade para pular para Executar o aplicativo.

A biblioteca go-redis de software livre é usada para interagir com o Cache do Azure para Redis.

A função main começa lendo o nome do host e a senha (chave de acesso) para a instância do Cache do Azure para Redis.

func main() {
    redisHost := os.Getenv("REDIS_HOST")
    redisPassword := os.Getenv("REDIS_PASSWORD")
...

Em seguida, estabelecemos uma conexão com o Cache do Azure para Redis. Usamos tls.Config--O Azure Cache para Redis aceita apenas conexões seguras com [TLS 1.2 como a versão mínima exigida]/azure-cache-for-redis/cache-remove-tls-10-11.md).

...
op := &redis.Options{Addr: redisHost, Password: redisPassword, TLSConfig: &tls.Config{MinVersion: tls.VersionTLS12}}
client := redis.NewClient(op)

ctx := context.Background()
err := client.Ping(ctx).Err()
if err != nil {
    log.Fatalf("failed to connect with redis instance at %s - %v", redisHost, err)
}
...

Se a conexão for bem-sucedida, manipuladores HTTP serão configurados para lidar com as operações POST e GET e o servidor HTTP será iniciado.

Observação

A gorilla mux library é usado para roteamento (embora não seja estritamente necessário e poderíamos ter usado a biblioteca padrão para este aplicativo de exemplo).

uh := userHandler{client: client}

router := mux.NewRouter()
router.HandleFunc("/users/", uh.createUser).Methods(http.MethodPost)
router.HandleFunc("/users/{userid}", uh.getUser).Methods(http.MethodGet)

log.Fatal(http.ListenAndServe(":8080", router))

O userHandlerstruct encapsula um redis.Client, que é usado pelos métodos createUser, getUser – o código para esses métodos não foi incluído para fins de agilidade.

createUser: aceita conteúdo JSON (contendo as informações do usuário) e salva-o como um HASH no Cache do Azure para Redis.
getUser: busca informações do usuário de HASH ou retorna uma resposta HTTP 404, se não for encontrada.

type userHandler struct {
    client *redis.Client
}
...

func (uh userHandler) createUser(rw http.ResponseWriter, r *http.Request) {
    // details omitted
}
...

func (uh userHandler) getUser(rw http.ResponseWriter, r *http.Request) {
    // details omitted
}

Clonar o aplicativo de exemplo

Comece clonando o aplicativo do GitHub.

Abra um prompt de comando e crie uma pasta chamada git-samples.
```
md "C:\git-samples"
```
Abra uma janela de terminal do Git, como git bash. Use o comando cd para mudar para a nova pasta, na qual você clonará o aplicativo de exemplo.
```
cd "C:\git-samples"
```
Execute o comando a seguir para clonar o repositório de exemplo. Este comando cria uma cópia do aplicativo de exemplo no seu computador.
```
git clone https://github.com/Azure-Samples/azure-redis-cache-go-quickstart.git
```

Executar o aplicativo

O aplicativo aceita conectividade e credenciais na forma de variáveis de ambiente.

Busque o Nome de host e as Chaves de Acesso (disponíveis por meio de Chaves de Acesso) para a instância do Cache do Azure para Redis no portal do Azure

Defina-as para as respectivas variáveis de ambiente:

set REDIS_HOST=<Host name>:<port> (e.g. <name of cache>.redis.cache.windows.net:6380)
set REDIS_PASSWORD=<Primary Access Key>

Na janela do terminal, mude para a pasta correta. Por exemplo:
```
cd "C:\git-samples\azure-redis-cache-go-quickstart"
```
No terminal, execute o comando a seguir para iniciar o aplicativo.
```
go run main.go
```

O servidor HTTP será iniciado na porta 8080.

Testar o aplicativo

Crie algumas entradas de usuário. O exemplo abaixo usa curl:

curl -i -X POST -d '{"id":"1","name":"foo1", "email":"foo1@baz.com"}' localhost:8080/users/
curl -i -X POST -d '{"id":"2","name":"foo2", "email":"foo2@baz.com"}' localhost:8080/users/
curl -i -X POST -d '{"id":"3","name":"foo3", "email":"foo3@baz.com"}' localhost:8080/users/

Busque um usuário existente com seu id:

curl -i localhost:8080/users/1

Você deve obter a resposta JSON como:

{
    "email": "foo1@bar",
    "id": "1",
    "name": "foo1"
}

Se tentar buscar um usuário que não existe, receberá um HTTP 404. Por exemplo:

curl -i localhost:8080/users/100

#response

HTTP/1.1 404 Not Found
Date: Fri, 08 Jan 2021 13:43:39 GMT
Content-Length: 0

Limpar os recursos

Se quiser continuar a usar os recursos que você criou neste artigo, conserve o grupo de recursos.

Caso contrário, se não pretende mais usar os recursos, você poderá excluir o grupo de recursos criado no Azure para evitar a cobrança.

Importante

A exclusão de um grupo de recursos é irreversível. Ao excluir o grupo de recursos, todos os recursos nele são excluídos permanentemente. Certifique-se de que não exclua acidentalmente o grupo de recursos ou os recursos incorretos. Se você criou os recursos dentro de um grupo de recursos existente que contém recursos que você quer manter, você pode excluir cada recurso individualmente em vez de excluir o grupo de recursos.

Para excluir um grupo de recursos

Entre no portal do Azure e selecione Grupos de recursos.
Selecione o grupo de recursos que você quer excluir.

Se existirem muitos grupos de recursos, use a caixa Filtrar para qualquer campo... e digite o nome do seu grupo de recursos que você criou para este artigo. Selecione o grupo de recursos na lista de resultados.
Selecione Excluir grupo de recursos.
Você receberá uma solicitação para confirmar a exclusão do grupo de recursos. Digite o nome do grupo de recursos para confirmar e selecione Excluir.

Após alguns instantes, o grupo de recursos, e todos os recursos nele são excluídos.

Próximas etapas

Neste guia de início rápido, você aprendeu a começar a usar o Go com o Cache do Azure para Redis. Você configurou e executou um aplicativo simples baseado na API REST para criar e obter informações do usuário apoiadas por uma estrutura de dados HASH do Redis.

Crie um aplicativo Web ASP.NET simples que usa um Cache do Azure para Redis.