Comment utiliser la file d'attente de messages dans Go ?

La file d'attente de messages est un modèle d'architecture système courant, qui joue un rôle extrêmement important dans la gestion d'une concurrence élevée et du traitement des tâches asynchrones. Dans le langage Go, grâce à certaines bibliothèques et outils de files d'attente de messages open source, l'utilisation des files d'attente de messages est devenue très pratique et simple.

Cet article explique comment utiliser les files d'attente de messages dans Go, notamment les éléments suivants :

Les avantages et les scénarios applicables de l'utilisation de la file d'attente de messages dans Go
1. Bibliothèque de file d'attente de messages en langage Go
2. Un exemple montre comment utiliser la file d'attente de messages dans Go
4. Comprendre la file d'attente des messages
5. La file d'attente des messages est un modèle architectural qui utilise des files d'attente pour mettre en cache, transmettre et stocker des messages de manière asynchrone. Les files d'attente de messages sont généralement divisées en trois parties : les producteurs, les consommateurs et les files d'attente. Le producteur envoie le message à la file d'attente et le consommateur récupère le message de la file d'attente pour le traitement. Le but de la file d'attente de messages est de découpler les dépendances temporelles et spatiales entre les producteurs et les consommateurs et de mettre en œuvre un traitement de tâches asynchrone.

La file d'attente de messages peut mettre en cache des données, mettre en œuvre un traitement asynchrone, un écrêtage de charge de pointe (pour traiter des demandes simultanées élevées dans un court laps de temps) et un équilibrage de charge, etc. C'est un composant important pour prendre en charge le conception de systèmes distribués à grande échelle.

File d'attente de messages commune

Il existe de nombreuses bibliothèques et outils de file d'attente de messages sur le marché qui prennent en charge divers langages de programmation, parmi lesquels les plus courants sont les suivants :

# 🎜🎜#

RabbitMQ : RabbitMQ est un système de file d'attente de messages open source qui prend en charge plusieurs protocoles et langages de programmation, tels que AMQP, STOMP, MQTT, etc. Les développeurs peuvent y accéder via différents langages clients, tels que Go, Java , Python, etc. RabbitMQ est écrit en langage Erlang et est largement utilisé pour prendre en charge des scénarios de traitement en temps réel tels que l'IoT, les discussions de groupe et la surveillance.

Apache Kafka : Apache Kafka est un système de file d'attente de messages basé sur le modèle de publication/abonnement. Il a été développé par LinkedIn et est principalement utilisé pour gérer le traitement continu des données en streaming. Kafka distribue les messages via plusieurs partitions pour prendre en charge un débit élevé et une évolutivité élevée.

ActiveMQ : ActiveMQ est un système de file d'attente de messages populaire basé sur JMS qui prend en charge plusieurs protocoles de transmission et accès à des langages de programmation, tels que AMQP, STOMP, Openwire, etc.

1. NSQ : NSQ est une plate-forme de traitement de messages distribué en temps réel, composée de deux composants : nsq et nsqd nsq est un serveur proxy TCP pour l'interaction client, tandis que nsqd est un service pour les messages persistants et les files d'attente. .
2. Avantages et scénarios applicables de l'utilisation des files d'attente de messages dans Go
3. Le langage Go prend en charge nativement les coroutines, l'utilisation de files d'attente de messages pour gérer des tâches asynchrones est donc particulièrement adaptée . Le langage Go fournit de nombreuses bibliothèques et outils open source pour les files d'attente de messages, qui sont également relativement pratiques à utiliser.
4. De plus, étant donné que la file d'attente de messages traite les messages de manière asynchrone, les tâches peuvent être déchargées pour éviter une concurrence élevée sur une seule machine. Par conséquent, la file d'attente de messages peut être utilisée dans les scénarios suivants :

Traitement de grandes quantités de données : comme le traitement de grandes quantités de données de serveur dans les journaux de sites Web, les tests de résistance, etc.

Traitement asynchrone et distribution des tâches : telles que l'envoi d'e-mails, la notification par SMS, etc.

File d'attente des tâches distribuées : telle que la file d'attente 0, la file d'attente en attente, etc. ; 🎜🎜#

Scénarios simultanés de plusieurs consommateurs : tels que les ventes flash commerciales d'électricité, les commentaires à haute concurrence, etc. ;
1. Découplage et expansion des applications : tels que l'intégration de notifications de services de messagerie externes et la séparation des données interaction entre les systèmes.
3. Bibliothèque de files d'attente de messages en langage Go
4. En langage Go, il existe de nombreuses bibliothèques de files d'attente de messages open source disponibles, telles que :
#🎜 🎜 #
5. Bibliothèque client AMQP de RabbitMQ : https://github.com/streadway/amqp

Bibliothèque client d'Apache Kafka : https://github.com/confluentinc/ confluent-kafka-go ;

Bibliothèque client NSQ : https://github.com/nsqio/go-nsq.

L'utilisation de ces bibliothèques open source peut facilement se connecter à différents systèmes de file d'attente de messages, permettant aux développeurs de se concentrer davantage sur le développement logique du secteur d'activité, améliorant ainsi l'efficacité du développement et la lisibilité du code.
1. Montrez comment utiliser la file d'attente des messages dans Passer à travers un exemple
2. Ci-dessous, nous montrerons comment utiliser la file d'attente de messages dans Passer à travers un exemple simple.
3. Supposons que nous souhaitions explorer les données d'image de certains sites Web et les enregistrer localement. Nous pouvons utiliser go pour terminer ce programme. Afin de réaliser un téléchargement asynchrone de certaines images, nous utilisons RabbitMQ comme file d'attente de messages et effectuons les étapes suivantes dans Go :

Install RabbitMQ

Install RabbitMQ, télécharger depuis le site officiel Adresse : https://www.rabbitmq.com/download.html ;

Configurer RabbitMQ Après l'installation, entrez dans le répertoire bin (veuillez ignorer le suffixe .bat pour les non-Windows. plates-formes) et exécutez : ./rabbitmqctl start, Start RabbitMQ ;

Créez un hôte virtuel MQ, exécutez : ./rabbitmqctl add_vhost test ;

Ajoutez des utilisateurs et attribuez des autorisations, exécutez : ./rabbitmqctl add_user test test, ./rabbitmqctl set_permissions -p test test ".

" ".
1. " ".*";
2. Démarrez l'interface de gestion Web RabbitMQ et exécutez : ./rabbitmq-plugins activez Rabbitmq_management, saisissez l'adresse http://localhost:15672 dans le navigateur pour accéder à l'interface de gestion.
3. Écriture de code
4. Nous pouvons utiliser la bibliothèque github.com/streadway/amqp pour interagir avec RabbitMQ. Ci-dessous le code.
Écrivez d'abord le code du robot, explorez l'adresse de l'image qui doit être téléchargée et envoyez-la à RabbitMQ :

5. func main() {
       spider()
   }
   
   func spider() {
       url := "https://www.example.com"
       doc, _ := goquery.NewDocument(url)
       doc.Find(".img_wrapper img").Each(func(i int, s *goquery.Selection) {
           imgUrl, _ := s.Attr("src")
           publishToMQ(imgUrl)
       })
   }
   
   func publishToMQ(msg string) {
       conn, err := amqp.Dial("amqp://test:test@localhost:5672/test")
       failOnError(err, "Failed to connect to RabbitMQ")
       defer conn.Close()
   
       ch, err := conn.Channel()
       failOnError(err, "Failed to open a channel")
       defer ch.Close()
   
       q, err := ch.QueueDeclare(
           "image_downloader", // name
           true,               // durable
           false,              // delete when unused
           false,              // exclusive
           false,              // no-wait
           nil,                // arguments
       )
       failOnError(err, "Failed to declare a queue")
   
       err = ch.Publish(
           "",     // exchange
           q.Name, // routing key
           false,  // mandatory
           false,  // immediate
           amqp.Publishing{
               ContentType: "text/plain",
               Body:        []byte(msg),
           })
       failOnError(err, "Failed to publish a message")
   
       log.Printf(" [x] Sent %s", msg)
   }

   Ensuite, écrivez le téléchargeur d'images. En écoutant la file d'attente de messages de RabbitMQ, le téléchargement d'images asynchrone est obtenu :

   func main() {
       consumeMQ()
   }
   
   func consumeMQ() {
       conn, err := amqp.Dial("amqp://test:test@localhost:5672/test")
       failOnError(err, "Failed to connect to RabbitMQ")
       defer conn.Close()
   
       ch, err := conn.Channel()
       failOnError(err, "Failed to open a channel")
       defer ch.Close()
   
       q, err := ch.QueueDeclare(
           "image_downloader", // name
           true,               // durable
           false,              // delete when unused
           false,              // exclusive
           false,              // no-wait
           nil,                // arguments
       )
       failOnError(err, "Failed to declare a queue")
   
       msgs, err := ch.Consume(
           q.Name, // queue
           "",     // consumer
           true,   // auto-ack
           false,  // exclusive
           false,  // no-local
           false,  // no-wait
           nil,    // args
       )
       failOnError(err, "Failed to register a consumer")
   
       forever := make(chan bool)
   
       go func() {
           for d := range msgs {
               log.Printf("Received a message: %s", d.Body)
               downloadImage(string(d.Body))
           }
       }()
   
       log.Printf(" [*] Waiting for messages. To exit press CTRL+C")
       <-forever
   }
   
   func downloadImage(url string) {
       resp, err := http.Get(url)
       if err != nil {
           log.Fatal(err)
       }
       defer resp.Body.Close()
   
       file, err := os.Create(uuid.New().String() + ".jpg")
       if err != nil {
           log.Fatal(err)
       }
       defer file.Close()
   
       _, err = io.Copy(file, resp.Body)
       if err != nil {
           log.Fatal(err)
       }
   
       log.Printf("Downloaded an image: %s", url)
   }

   Dans le code ci-dessus, nous avons créé une file d'attente de travail "image-downloader" après que le producteur ait analysé l'adresse de l'image du html. page, cela fonctionne. Envoyez des messages dans la file d'attente. Le consommateur écoutera la file d'attente de travail et, après avoir reçu le message, appellera la fonction downloadImage pour télécharger le fichier image.

   L'exemple ci-dessus est un cas d'utilisation simple utilisant RabbitMQ. L'utilisation d'autres bibliothèques de files d'attente de messages est similaire, il vous suffit d'implémenter des connexions et des opérations via différentes API.

   Overview

   Dans cet article, nous présentons et expliquons ce qu'est une file d'attente de messages Dans un grand nombre de scénarios de traitement de données, la consommation asynchrone est essentielle. Le langage Go rend le traitement des tâches asynchrones simple et efficace grâce à son propre mécanisme de coroutine. Couplé aux riches bibliothèques open source du langage Go lui-même, il devient extrêmement simple d'utiliser des files d'attente de messages pour implémenter un traitement de messages asynchrone.

   À travers les exemples ci-dessus, nous pouvons voir que lors de la mise en œuvre d'un traitement de tâches asynchrone, l'utilisation de files d'attente de messages peut considérablement améliorer l'efficacité du traitement, et l'utilisation de files d'attente de messages en langage Go est également très pratique. Dans les projets, il est recommandé d'utiliser des bibliothèques de files d'attente de messages open source, telles que RabbitMQ ou Apache Kafka.

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!