So installieren Sie RabbitMQ schnell in Docker

#Geben Sie die Version an, die die Web-Kontrollseite docker pull rabbitmq:management enthält

#Methode 1: Standardmäßiger Gastbenutzer, das Passwort lautet ebenfalls Gast
docker run -d --hostname mein-Kaninchen --name Kaninchen -p 15672:15672 -p 5672:5672 rabbitmq:management

#Methode 2: Benutzernamen und Passwort festlegen docker run -d --hostname my-rabbit --name rabbit -e RABBITMQ_DEFAULT_USER=Benutzer -e RABBITMQ_DEFAULT_PASS=Passwort -p 15672:15672 -p 5672:5672 rabbitmq:management

#Produzent Produzent Code Paket Haupt

importieren (
  "fmt"

  "Protokoll"

  „github.com/streadway/amqp“
)

Konstante (
  //AMQP-URI

  uri = "amqp://guest:[email protected]:5672/" // 10.0.0.11 ist die Host-IP

  //Dauerhafter AMQP-Austauschname

  Austauschname = ""

  //Dauerhafter AMQP-Warteschlangenname

  Warteschlangenname = "Testwarteschlangen"

  //Nachrichtentext

  bodyMsg string = "hallo Engel"
)

//Wenn ein Fehler auftritt, dann Ausgabe func failOnError(err error, msg string) {

  wenn err != nil {

    log.Fatalf("%s: %s", Nachricht, Fehler)

    Panik(fmt.Sprintf("%s: %s", Nachricht, Fehler))

  }

}

Funktion main() {

  //Rufen Sie die Funktion zum Veröffentlichen von Nachrichten auf: publish(uri, exchangeName, queueName, bodyMsg)

  log.Printf("veröffentlicht %dB OK", len(bodyMsg))

}

//Publisher-Methode //@amqpURI, amqp-Adresse //@exchange, Exchange-Name //@queue, Warteschlangenname //@body, Body-Inhalt func publish(amqpURI-Zeichenfolge, Exchange-Zeichenfolge, Warteschlangen-Zeichenfolge, Body-Zeichenfolge) {

  //Verbindung herstellen log.Printf("dialing %q", amqpURI)

  Verbindung, Fehler := amqp.Dial(amqpURI)

  failOnError(err, "Verbindung zu RabbitMQ konnte nicht hergestellt werden")

  Verbindung verschieben.Schließen()

  //Kanal erstellen

  log.Printf("Verbindung hergestellt, Kanal wird abgerufen")

  Kanal, Fehler := Verbindung.Kanal()

  failOnError(err, "Kanal konnte nicht geöffnet werden")

  Kanal verschieben.Schließen()

  log.Printf("Warteschlange erhalten, %q deklariert", Warteschlange)

  //Eine Warteschlange erstellen

  q, err := Kanal.QueueDeclare(

    Warteschlangenname, // Name

    false, // dauerhaft

    false, // löschen, wenn nicht verwendet

    false, // exklusiv

    false, // nein-warten

    nil, // Argumente

  )

  failOnError(err, "Fehler beim Deklarieren einer Warteschlange")

  log.Printf("deklarierte Warteschlange, veröffentlicht %dB-Body (%q)", len(Body), Body)

  // Der Produzent kann nur an die Börse senden, nicht direkt an die Warteschlange. // Jetzt verwenden wir die Standardbörse (Name ist ein leeres Zeichen). Diese Standardbörse ermöglicht uns das Senden an die angegebene Warteschlange.

  // routing_key ist der angegebene Warteschlangenname err = channel.Publish(

    Austausch, // Austausch

    q.Name, // Routing-Schlüssel

    false, // obligatorisch

    false, // sofort

    amqp.Veröffentlichung{

      Überschriften: amqp.Table{},

      Inhaltstyp: "text/plain",

      Inhaltskodierung: "",

      Körper: []byte(körper),
    })

  failOnError(err, "Die Veröffentlichung einer Nachricht ist fehlgeschlagen")

}

#Produzent
Paket Haupt

importieren (
  "fmt"
  „github.com/streadway/amqp“
  "Protokoll"
  "os"
  "Saiten"
)

Konstante (
  //AMQP-URI
  uri = "amqp://guest:[email protected]:5672/"
  //Dauerhafter AMQP-Austauschname
  Austauschname = ""
  //Dauerhafter AMQP-Warteschlangenname
  Warteschlangenname = "Testwarteschlangen-Bestätigungen"
)

//Wenn ein Fehler auftritt, dann Ausgabe func failOnError(err error, msg string) {
  wenn err != nil {
    log.Fatalf("%s: %s", Nachricht, Fehler)
    Panik(fmt.Sprintf("%s: %s", Nachricht, Fehler))
  }
}

Funktion main() {
  bodyMsg := bodyFrom(os.Args)
  //Rufen Sie die Funktion zum Veröffentlichen von Nachrichten auf: publish(uri, exchangeName, queueName, bodyMsg)
  log.Printf("veröffentlicht %dB OK", len(bodyMsg))
}

Funktion bodyFrom(args []string) string {
  var s Zeichenfolge
  wenn (Länge(Argumente) < 2) || os.Args[1] == "" {
    s = "hallo Engel"
  } anders {
    s = Zeichenfolgen.Join(args[1:], " ")
  }
  Rücksendungen
}

//Publisher-Methode //@amqpURI, amqp-Adresse //@exchange, Exchange-Name //@queue, Warteschlangenname //@body, Body-Inhalt func publish(amqpURI-String, Exchange-String, Queue-String, Body-String) {
  //Verbindung herstellen log.Printf("dialing %q", amqpURI)
  Verbindung, Fehler := amqp.Dial(amqpURI)
  failOnError(err, "Verbindung zu RabbitMQ konnte nicht hergestellt werden")
  Verbindung verschieben.Schließen()

  //Kanal erstellen
  log.Printf("Verbindung hergestellt, Kanal wird abgerufen")
  Kanal, Fehler := Verbindung.Kanal()
  failOnError(err, "Kanal konnte nicht geöffnet werden")
  Kanal verschieben.Schließen()

  log.Printf("Warteschlange erhalten, %q deklariert", Warteschlange)

  //Eine Warteschlange erstellen
  q, err := Kanal.QueueDeclare(
    Warteschlangenname, // Name
    false, // dauerhaft
    false, // löschen, wenn nicht verwendet
    false, // exklusiv
    false, // nein-warten
    nil, // Argumente
  )
  failOnError(err, "Fehler beim Deklarieren einer Warteschlange")

  log.Printf("deklarierte Warteschlange, veröffentlicht %dB-Body (%q)", len(Body), Body)

  // Der Produzent kann nur an den Austausch senden, es kann nicht direkt an die Warteschlange gesendet werden.
  // Im Moment verwenden wir den Standardaustausch (mit einer leeren Zeichenfolge als Namen). Dieser Standardaustausch ermöglicht uns das Senden an eine bestimmte Warteschlange.
  // Routing-Schlüssel ist der angegebene Warteschlangenname.
  err = Kanal.Veröffentlichen(
    Austausch, // Austausch
    q.Name, // Routing-Schlüssel
    false, // obligatorisch
    false, // sofort
    amqp.Veröffentlichung{
      Überschriften: amqp.Table{},
      Inhaltstyp: "text/plain",
      Inhaltskodierung: "",
      Körper: []byte(körper),
    })
  failOnError(err, "Die Veröffentlichung einer Nachricht ist fehlgeschlagen")
}