Køutløser

7 minutter

En meldingstrek er en programvarekomponent som brukes til å håndtere meldinger mellom prosesser, tråder eller programmer. En kø kan lagre en melding, og arbeidere kan hente meldingen når det passer.

I skyen kan meldingskøer generere hendelser med en nyttelast. En tjeneste som Azure Functions kan lytte til en slik melding og kjøre koden når en melding publiseres.

Arbeide med meldingkøer

For at en Azure-funksjon skal kunne bruke en melding fra en meldingkø, trenger den en utløser og muligens en binding.

En Azure-funksjon må lytte til en bestemt kø, slik at koden utløses når en ny melding publiseres i denne køen. Hvis du vil konfigurere en utløser, må du oppgi riktig legitimasjon, slik at utløserkoden vet hvordan du kobler til meldingskøen. Du oppretter en oppføring i function.json-filen for funksjonen som lytter til køen. Angi disse egenskapene for en oppføring i bindings elementet:

Eiendom	Verdi
`name`	Et navn som du kan referere til i kode
`type`	`queueTrigger`
`direction`	`in`
`queueName`	Hva køen kalles
`connection`	En konfigurasjonsvariabel i local.settings.json

En eksempeloppføring kan defineres slik:

{
    "name": "myQueueItem",
    "type": "queueTrigger",
    "direction": "in",
    "queueName": "messages-incoming",
    "connection": "AzureWebJobsStorage"
  }

Hvis denne køen finnes på en lagringskonto, er den AzureWebJobsStorage verdien verdien for tilkoblingsstrengen.

Du trenger ikke bare en binding når du bruker en melding fra en kø. Hvis du imidlertid vil skrive til en kø, trenger du en utdatabinding. Med en slik binding får du en referanse til den tiltenkte køen.

Notat

For øyeblikket støttes bare utdatabindinger for køer.

Utvikle lokalt

Som utvikler ønsker du korte tilbakemeldingssykluser. Du ønsker også å sikre at utvikleropplevelsen er så nær et produksjonsmiljø som mulig. En måte å oppnå begge disse målene på, er å bruke en køemulator.

Med en køemulator kan du simulere reelle kømeldinger som Azure-funksjonen vil svare på. Slik bruker du emulatoren:

Installer emulatoren. Søk etter Azurite- i Visual Studio Code, eller last ned Azurite-utvidelsen.
Hvis du vil bruke emulatorfunksjonaliteten, starter du den ved å velge Azure: Start Queue Service på kommandopaletten.

Når du kjører denne kommandoen, starter en lytter kalt Azure Storage Explorer som et annet program kan fortsette på. Storage Explorer er et klientprogram som lar deg bla gjennom skyressursene og bruke emulatorfunksjonalitet.
Last ned Azure Storage Explorer. Deretter åpner du programmet, og du ser følgende indikasjon på at emulatoren fungerer:
Opprett en kø på emulatoren. Du bruker denne køen som en del av konfigurasjonen av funksjonsendepunktet. Ved å høyreklikke på køelementet kan du opprette en ny kø.
Hvis du vil sikre at Functions-appen bruker emulatoren, må du angi tilkoblingsstrengen riktig. Åpne local.settings.json, finn AzureWebJobsStorage elementet, og gi den verdien "UseDevelopmentStorage=true".

Notat

Husk å angi denne egenskapen på en annen måte når du flytter til skyen. Den bør peke på en faktisk ressurs på Azure når den er i produksjon.

Bygg funksjonen

Du har nå konfigurert en lokal emulator, og den har en kø på seg. Du har også konfigurert prosjektet slik at det peker til den lokale emulatoren. Nå må du opprette en funksjon for å håndtere en køutløser.

Opprette et funksjonsendepunkt

Du er klar til å opprette en funksjon som kan håndtere innkommende kømeldinger. Opprett en mappe for funksjonen, og gi den et navn, for eksempel queueTrigger. Opprett deretter en function.json fil og gi den følgende innhold:

{
  "bindings": [{
    "name" "queueItem",
    "type": "queueTrigger",
    "direction": "in",
    "queueName" : "items",
    "connection": "AzureWebJobsStorage"
  }]
}

Verdien for det name elementet er viktig, fordi du vil referere til det senere i koden for å analysere innkommende data fra køen. Det må være av typen queueTrigger slik at køen utløser den når det er en ny melding.

Elementet queueName identifiserer unikt hvilken kø du samhandler med. Det du skriver inn her, må samsvare med det du kaller køen i emulatoren, eller det du senere kaller den faktiske køen i Azure.

Det connection elementet peker til verdien for AzureWebJobsStorage elementet i local.settings.json.

Håndtere en kømelding

Hvis du vil håndtere en innkommende kømelding, må du skrive kode som kan analysere meldingen du trenger. På det tidspunktet kan du bestemme hva du skal gjøre videre. Du kan for eksempel starte en nettforespørsel, plassere meldingen i en annen kø eller sende meldingen til en database.

Konfigurere en rute

Du trenger en rute for å håndtere innkommende forespørsler. Azure Functions håndterer forespørsler til en kø ved roten. Når du konfigurerer en rute som følger, aktiveres forespørselen som http://localhost:<port>/queueTrigger:

http.HandleFunc("/queueTrigger", handleQueueTrigger)

Dekode en forespørsel

Når kømeldingen sendes til deg, har den denne figuren:

{
  "Data": {
    "queueItem": "your message"
  },
  "Metadata": {
    "DequeueCount": 1,
    "ExpirationTime": "2019-10-16T17:58:31+00:00",
    "Id": "800ae4b3-bdd2-4c08-badd-f08e5a34b865",
    "InsertionTime": "2019-10-09T17:58:31+00:00",
    "NextVisibleTime": "2019-10-09T18:08:32+00:00",
    "PopReceipt": "AgAAAAMAAAAAAAAAAgtnj8x+1QE=",
    "sys": {
      "MethodName": "QueueTrigger",
      "UtcNow": "2019-10-09T17:58:32.2205399Z",
      "RandGuid": "24ad4c06-24ad-4e5b-8294-3da9714877e9"
    }
  }
}

Som en del av dekodingen av den innkommende forespørselen, trenger du en hjelpestruktur som modellerer den foregående meldingen. Det skal se slik ut:

type InvokeRequest {
   Data map[string]json.RawMessage
   Metadata map[string]interface{}
}

Begynn å skrive kode for å ta den innkommende forespørselen og dekode den:

func handleQueueTrigger(w http.ResponseWrite, r *http.Request) {
   var invokeRequest InvokeRequest
   d := json.NewDecoder(r.Body)
   d.Decode(&invokeRequest)
}

Nå er du på et punkt der forespørselen er dekodet, men du må analysere selve kømeldingen.

Analysere en kømelding

Når forespørselen er dekodet, kan kømeldingen hentes fra forespørselen på Data-egenskapen. Du må også referere til meldingen etter den name egenskapsverdien du konfigurert i function.json-filen. Koden for henting av meldingen er en en-liner som dette:

invokeRequest.Data["queueItem"]

Fordi du må kunne lese denne meldingen i klartekst, bruker du et JSON-bibliotek og analyserer den. JSON-biblioteket bruker en Unmarshal() metode som tar to parametere: meldingen som skal analyseres og variabelen for å plassere den analyserte meldingen på. Så koden din må se slik ut:

var parsedMessage string
json.Unmarshal(invokeRequest.Data["queueItem"], &parsedMessage)

På dette tidspunktet inneholder parsedMessage meldingen. Hvis du vil skrive den ut til konsollen, bruker du følgende kode:

fmt.Println(parsedMessage) // your message

Notat

Hvis meldingen er noe mer avansert enn en streng, må parsedMessage ha en struktur som samsvarer med formen på det queueMessage peker til.

Utløse en melding

Hvis du vil teste programmet, kan du bruke Azure Storage Explorer. Velg knappen Legg til melding i høyre rute i verktøyet for å opprette en melding i køen.

Skjermbilde som viser knappen for å legge til en melding i køen.

Hvis du har Functions-appen og den kjører på dette tidspunktet, utløses bindingen, og koden aktiveres.

Tilbakemeldinger

Var denne siden nyttig?