Implémentation de systèmes distribués à l'aide du framework Web Buffalo de Golang

Un système distribué est un système composé de plusieurs ordinateurs indépendants avec des données et des tâches partagées entre eux. Ces ordinateurs communiquent entre eux sur le réseau pour accomplir une tâche ensemble. Dans ce système, chaque ordinateur est indépendant et peut utiliser différents systèmes d’exploitation et langages de programmation. Pour que ces ordinateurs fonctionnent ensemble, nous avons besoin d’un cadre pour coordonner leurs opérations. Dans cet article, nous présenterons comment utiliser le framework Buffalo de Golang pour implémenter un système distribué.

Golang est un langage de programmation efficace, et son utilisation dans des systèmes distribués est meilleure que d'autres langages. Par conséquent, nous avons choisi Golang comme langage de développement. Le framework Buffalo est un framework Web Golang populaire qui offre les avantages d'un développement rapide et d'un développement collaboratif. Dans ce cadre, nous pouvons utiliser ses services d'automatisation pour créer et gérer des applications.

Lors de la création d'un système distribué, nous devons prendre en compte les facteurs suivants :

1. Communiquer entre eux : les ordinateurs d'un système distribué doivent communiquer entre eux pour travailler ensemble. Pour y parvenir, nous pouvons utiliser l'API RESTful ou le protocole gRPC.
2. Synchronisation des données : les ordinateurs d'un système distribué étant indépendants, ils peuvent avoir des données différentes. Par conséquent, nous devons réfléchir à la manière de synchroniser ces données.
3. Équilibrage de charge : afin de rendre un système distribué plus efficace, nous devons allouer des tâches aux ordinateurs disposant de ressources informatiques disponibles.

Voyons maintenant comment utiliser le framework Buffalo pour implémenter ces fonctions.

Création d'une application Buffalo

Nous devons d'abord créer une application Buffalo sur le serveur. Nous pouvons utiliser Buffalo CLI pour accomplir cette tâche. Installez la CLI Buffalo et créez une nouvelle application Buffalo via la ligne de commande suivante :

$ go get -u -v github.com/gobuffalo/buffalo/cli/v2
$ buffalo new appname

Buffalo générera une structure d'application de base. Nous pouvons utiliser la commande suivante pour démarrer le serveur :

$ buffalo dev

Cette commande démarrera un serveur Web, puis nous pourrons visiter http://127.0.0.1:3000 dans le navigateur pour afficher l'application.

Créer une API RESTful

Ensuite, nous devons créer une API RESTful pour que les ordinateurs d'un système distribué puissent communiquer entre eux. Nous pouvons utiliser les services automatisés du framework Buffalo pour accomplir cette tâche.

Tout d'abord, nous devons créer un contrôleur qui gère les requêtes API. Nous pouvons utiliser la commande suivante pour créer un contrôleur :

$ buffalo generate resource user name email

Cette commande générera un contrôleur nommé "user", et le contrôleur contient deux paramètres : "name" et "email". Nous pouvons ajouter une logique au contrôleur pour lui permettre de répondre à différents types de demandes.

Pour que les ordinateurs d'un système distribué communiquent entre eux, nous devons créer des requêtes POST et GET. Nous pouvons ajouter le code suivant dans le contrôleur pour gérer ces requêtes :

func (v *UsersResource) Create(c buffalo.Context) error {
    user := &models.User{}
    if err := c.Bind(user); err != nil {
        return err
    }

    // Add validation logic here!

    tx := c.Value("tx").(*pop.Connection)
    if err := tx.Create(user); err != nil {
        return err
    }

    return c.Render(201, r.JSON(user))
}

func (v *UsersResource) List(c buffalo.Context) error {
    users := &models.Users{}
    tx := c.Value("tx").(*pop.Connection)
    if err := tx.All(users); err != nil {
        return err
    }

    return c.Render(200, r.JSON(users))
}

Ces codes géreront les requêtes POST et GET et renverront les données de réponse au format JSON au client.

Utilisation du protocole gRPC

En plus de l'API RESTful, nous pouvons également utiliser le protocole gRPC pour établir la communication entre les ordinateurs. Le framework Buffalo prend en charge le protocole gRPC et nous pouvons installer le plugin Buffalo-gRPC à l'aide de la commande suivante :

$ buffalo plugins install buffalo-grpc

Ensuite, nous devons générer le code du service gRPC pour notre application. Nous pouvons utiliser la commande suivante pour générer du code :

$ buffalo generate grpc user

Cette commande générera un service gRPC nommé "user".

Dans le code côté serveur, nous devons implémenter les méthodes définies dans le service gRPC. Nous pouvons implémenter ces méthodes dans le code suivant :

type UserServer struct{}

func (s *UserServer) GetUser(ctx context.Context, req *user.GetUserRequest) (*user.GetUserResponse, error) {
    // Insert user retrieval logic here
}

func (s *UserServer) CreateUser(ctx context.Context, req *user.CreateUserRequest) (*user.User, error) {
    // Insert user creation logic here
}

Dans le code client, nous pouvons utiliser le code suivant pour appeler le service gRPC :

conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
if err != nil {
    log.Fatalf("failed to connect: %s", err)
}
defer conn.Close()

client := user.NewUserClient(conn)
res, err := client.GetUser(context.Background(), &user.GetUserRequest{Id: "123"})
if err != nil {
    log.Fatalf("failed to get user: %s", err)
}

log.Printf("user: %v", res)

Utiliser Redis comme cache dans un système distribué

Dans un système distribué, dans commander Pour accélérer l'accès aux données, nous utilisons généralement la mise en cache. Redis est un outil de mise en cache populaire qui prend en charge les systèmes distribués et nous permet de stocker et de récupérer rapidement des données. Nous pouvons installer Redis en utilisant la commande suivante :

$ brew install redis

Ensuite, nous pouvons utiliser Redis comme cache dans notre application. Nous pouvons utiliser la commande suivante pour installer le plugin Redis :

$ buffalo plugins install buffalo-redis

Ensuite, nous pouvons utiliser le code suivant dans l'application pour configurer Redis :

var (
    RedisClient *redis.Client
)

func init() {
    RedisClient = redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
}

func main() {
    app := buffalo.New(buffalo.Options{})
    app.Use(midware.Redis(RedisClient))
    // ...
}

Ensuite, nous pouvons utiliser le code suivant dans le contrôleur pour stocker les données dans Redis Center :

func (v *UsersResource) Create(c buffalo.Context) error {
    user := &models.User{}
    if err := c.Bind(user); err != nil {
        return err
    }

    // Add validation logic here!

    if err := RedisClient.Set("user_"+user.ID.String(), user, 0).Err(); err != nil {
        return err
    }

    // Add logic to store user in database

    return c.Render(201, r.JSON(user))
}

Dans cet exemple, nous stockons l'utilisateur dans un cache Redis avec l'ID de l'utilisateur comme clé. Cela nous permettra de récupérer rapidement les données utilisateur ultérieurement.

Réaliser l'équilibrage de charge

Enfin, nous devons implémenter la fonction d'équilibrage de charge. Dans un système distribué, nous voulons pouvoir attribuer des tâches informatiques aux ordinateurs disposant de ressources informatiques disponibles. Nous pouvons utiliser un serveur proxy inverse pour réaliser cette tâche.

Nginx est un serveur proxy inverse populaire qui prend en charge l'équilibrage de charge et le cryptage HTTPS. Nous pouvons installer Nginx sur le serveur et utiliser le fichier de configuration suivant pour réaliser l'équilibrage de charge :

http {
    upstream app_servers {
        server 127.0.0.1:3001;
        server 127.0.0.1:3002;
        server 127.0.0.1:3003;
    }

    server {
        listen 80;
        server_name example.com;

        location / {
            proxy_pass http://app_servers;
        }
    }
}

Ce fichier de configuration distribue les requêtes à trois serveurs différents et utilise un algorithme round-robin pour décider à quel serveur distribuer la requête.

Conclusion

En utilisant le framework Buffalo, nous pouvons rapidement mettre en œuvre des systèmes distribués et prendre en charge plusieurs protocoles de communication, notamment l'API RESTful et gRPC. Nous pouvons également utiliser Redis pour accélérer l'accès aux données et réaliser un équilibrage de charge en utilisant un serveur proxy inverse. Grâce à ces méthodes, nous pouvons rendre les systèmes distribués plus efficaces et atteindre des vitesses de calcul plus rapides.

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!