Olá Breno!

Implementar autenticação e autorização com JWT em uma API Rest é uma ótima ideia para complementar o curso que você está fazendo. O JWT (JSON Web Token) é um método seguro de autenticação e autorização amplamente utilizado em aplicações web.

Para implementar JWT em uma API Rest em Go, você precisará de algumas bibliotecas. Uma opção popular é a biblioteca "github.com/dgrijalva/jwt-go". Com ela, você pode facilmente gerar e validar tokens JWT.

Aqui está um exemplo básico de como implementar autenticação e autorização com JWT em uma API Rest em Go:

package main

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

    "github.com/dgrijalva/jwt-go"
)

var jwtKey = []byte("chave_secreta_do_jwt")

func main() {
    http.HandleFunc("/login", login)
    http.HandleFunc("/api", authMiddleware(apiHandler))

    fmt.Println("Servidor iniciado na porta 8080")
    http.ListenAndServe(":8080", nil)
}

func login(w http.ResponseWriter, r *http.Request) {
    // Verifica as credenciais do usuário
    username := r.FormValue("username")
    password := r.FormValue("password")

    // Verifica se as credenciais são válidas
    if username == "usuario" && password == "senha" {
        // Cria um token JWT com uma data de expiração
        expirationTime := time.Now().Add(5 * time.Minute)
        claims := &jwt.StandardClaims{
            ExpiresAt: expirationTime.Unix(),
        }

        token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
        tokenString, err := token.SignedString(jwtKey)
        if err != nil {
            w.WriteHeader(http.StatusInternalServerError)
            return
        }

        // Retorna o token JWT para o cliente
        w.Write([]byte(tokenString))
    } else {
        w.WriteHeader(http.StatusUnauthorized)
        return
    }
}

func authMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // Obtém o token JWT do cabeçalho da requisição
        tokenString := r.Header.Get("Authorization")
        if tokenString == "" {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }

        // Valida o token JWT
        token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
            return jwtKey, nil
        })
        if err != nil || !token.Valid {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }

        // Chama o próximo handler
        next(w, r)
    }
}

func apiHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("API Rest protegida por autenticação e autorização com JWT"))
}

Nesse exemplo, temos um endpoint "/login" onde o usuário pode fazer login e obter um token JWT válido. O token é então enviado no cabeçalho "Authorization" em todas as requisições para o endpoint "/api". O middleware "authMiddleware" verifica se o token é válido antes de chamar o handler "apiHandler".

Lembre-se de adaptar esse exemplo de acordo com as necessidades da sua API Rest e de armazenar a chave secreta do JWT de forma segura.

Espero que isso te ajude a implementar autenticação e autorização com JWT em sua API Rest em Go. Se tiver mais alguma dúvida, é só me dizer!

Espero ter ajudado e bons estudos!