Méthode d'application de grpc et http2 de la fonction Golang

Introduction
Depuis la sortie de Golang, il est populaire parmi les développeurs. Aujourd'hui, de plus en plus d'entreprises et de développeurs commencent à utiliser Golang pour créer des applications de microservices hautes performances. Dans cet article, nous explorerons les méthodes d'application de grpc et http2 dans les fonctions Golang.

Qu'est-ce que gRPC ?

gRPC est un framework RPC open source moderne et hautes performances. Il rend la communication entre les applications client et serveur plus facile et plus fiable. gRPC est open source par Google. Il est plus pratique d'utiliser gRPC dans les fonctions Golang car il utilise les tampons de protocole comme protocole de données.

Protocol Buffers est un protocole de données sérialisées léger et efficace qui peut sérialiser des données structurées en bytecode pour la transmission. Les concepteurs peuvent utiliser des fichiers .proto pour définir des structures de données, puis utiliser des plug-ins fournis par gRPC pour générer du code pour différents langages de programmation à partir des fichiers .proto.

Les scénarios d'application de gRPC incluent, sans s'y limiter :

Appareils IoT : gRPC est très approprié pour la communication entre l'IoT et les capteurs car il est très léger et efficace.

Microservices : en tant que framework RPC, gRPC fonctionne bien dans une architecture de microservices car il peut gérer de grandes quantités de données et de requêtes.

Systèmes distribués : gRPC est un framework RPC idéal pour les systèmes distribués en raison de sa haute disponibilité, de ses hautes performances et de ses caractéristiques multiplateformes.

Comme de nombreuses applications fonctionnelles Golang, gRPC est un service basé sur des flux, ce qui signifie que le client et le serveur peuvent s'envoyer des flux de données plutôt qu'une requête-réponse instantanée.

Comment utiliser gRPC

Ce qui suit est le code Go qui fait référence à gRPC. Avec la méthode suivante, cela nous aidera à démarrer l'application gRPC et à nous connecter au serveur.

import (
    "github.com/gin-gonic/gin"
    "google.golang.org/grpc"
)

func main() {
    router := gin.Default()
    //grpc服务连接地址
    conn, err := grpc.Dial("127.0.0.1:50051", grpc.WithInsecure())
    if err != nil {
        panic(err)
    }
    //关闭连接
    defer conn.Close()
    //启动路由
    router.Run(":8080")
}

Dans ce code, nous nous connectons au serveur gRPC sur localhost et démarrons notre routeur sur le port 8080. Les fonctions des routeurs Golang peuvent rendre les applications plus pratiques et plus fiables.

Implémentation du serveur gRPC

Voici le code pour créer un serveur gRPC dans une fonction Golang :

import (
    "context"
    "github.com/gin-gonic/gin"
    "google.golang.org/grpc"
    "google.golang.org/grpc/reflection"
    "net"
)

//定义Service
type UserService struct {}

//实现Service方法
func (u *UserService) GetUser(ctx context.Context, request *user.GetRequest) (*user.GetResponse, error) {
    user := new(GetResponse)
    return user, nil
}

func main() {
    listener, err := net.Listen("tcp", ":50051")
    if err != nil {
        panic(err)
    }
    //新建grpc服务
    grpcServer := grpc.NewServer()
    //在服务上注册UserService
    user.RegisterUserServiceServer(grpcServer, &UserService{})
    //refection服务
    reflection.Register(grpcServer)

    if err := grpcServer.Serve(listener); err != nil {
        panic(err)
    }
}

Le code ci-dessus crée notre serveur gRPC et implémente le service et la méthode. Nous définissons un type appelé UserService, qui implémente la méthode GetUser. Ensuite, nous avons démarré le serveur grpc et l'avons enregistré auprès du UserService.

Comme vous pouvez le voir dans le code ci-dessus, gRPC est un framework RPC puissant qui peut être utilisé pour une communication fiable et efficace entre les serveurs et les clients.

Qu'est-ce que HTTP/2 ?

Dans le cas de HTTP/2, un pipeline de communication binaire persistant est utilisé entre le client et le serveur, et ce pipeline peut gérer plusieurs requêtes et réponses en parallèle. HTTP/2 prend également en charge des fonctionnalités importantes telles que le push du serveur, la compression d'en-tête et le contrôle de flux.

Comment utiliser HTTP/2

Ce qui suit est le code Go qui fait référence à HTTP/2. Avec la méthode suivante, cela nous aidera à démarrer une application HTTP/2 et à nous connecter au serveur.

import (
    "github.com/gin-gonic/gin"
    "golang.org/x/net/http2"
    "golang.org/x/net/http2/h2c"
    "net/http"
)

func main() {
    router := gin.Default()

    h2s := &http2.Server{}

    router.Use(h2c.NewHandler(http.DefaultServeMux, h2s))

    server := &http.Server{
        Addr:    ":8080",
        Handler: router,
    }
    server.ListenAndServeTLS("cert.pem", "key.pem")
}

Dans le code ci-dessus, nous utilisons le package gin dans la fonction Golang pour gérer les requêtes HTTP/2. Nous avons créé un serveur HTTP/2 et accédé au serveur en utilisant le protocole HTTPS sur le navigateur.

Dans le cas de HTTP/2, nous avons besoin d'un certificat et d'une clé pour utiliser le protocole HTTPS. Lorsque nous appellerons la méthode server.ListenAndServeTLS, elle utilisera le certificat et la clé pour démarrer le serveur HTTPS.

Conclusion

Dans cet article, nous avons exploré comment utiliser gRPC et HTTP/2 dans les fonctions Golang. gRPC est un framework RPC hautes performances qui permet une communication fiable et efficace entre les serveurs et les clients. HTTP/2 est un nouveau protocole HTTP qui améliore les performances et l'efficacité des sites Web.

Essayez gRPC et HTTP/2 dans votre prochaine application fonctionnelle Golang pour améliorer la vitesse et les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!