Azure Web PubSub-utlösare och bindningar för Azure Functions

Artikel
01/12/2024

Den här referensen beskriver hur du hanterar Web PubSub-händelser i Azure Functions.

Web PubSub är en Azure-hanterad tjänst som hjälper utvecklare att enkelt skapa webbprogram med realtidsfunktioner och publiceringsprenumerationsmönster.

Åtgärd	Typ
Kör en funktion när meddelanden kommer från tjänsten	Utlösarbindning
Binda begäran till målobjekt under Http-utlösare för förhandlingar och överordnade begäranden	Indatabindning
Anropa tjänståtgärder	Utdatabindning

Referensdokumentation | för källkodspaketets | API-referens Produktdokumentation | – exempel |

Lägg till i din Functions-app

När du arbetar med utlösaren och bindningarna måste du referera till rätt paket. NuGet-paketet används för .NET-klassbibliotek medan tilläggspaketet används för alla andra programtyper.

Språk	Lägg till efter...	Anmärkningar
C#	Installera NuGet-paketet, förhandsversion av version
C#-skript, JavaScript, Python, PowerShell	Installera uttryckligen tillägg, Använd tilläggspaket	Azure Tools-tillägget rekommenderas att användas med Visual Studio Code.
C#-skript (endast online i Azure-portalen)	Lägga till en bindning	Information om hur du uppdaterar befintliga bindningstillägg utan att behöva publicera om funktionsappen finns i Uppdatera dina tillägg.

Nyckelbegrepp

Diagram showing the workflow of Azure Web PubSub service working with Function Apps.

(1)-(2) WebPubSubConnection indatabindning med HttpTrigger för att generera klientanslutning.

(3)-(4) WebPubSubTrigger utlösarbindning eller WebPubSubContext indatabindning med HttpTrigger för att hantera tjänstbegäran.

(5)-(6) WebPubSub utdatabindning för begärandetjänsten gör något.

Utlösarbindning

Använd funktionsutlösaren för att hantera begäranden från Azure Web PubSub-tjänsten.

WebPubSubTrigger används när du behöver hantera begäranden från tjänstsidan. Mönstret för utlösarens slutpunkt skulle vara som nedan, vilket bör anges på webbpubtjänstsidan (Portal: inställningar –> händelsehanterare –> URL-mall). I slutpunktsmönstret krävsfrågedelen code=<API_KEY> när du använder Azure-funktionsappen av säkerhetsskäl. Nyckeln finns i Azure-portalen. Hitta funktionsappens resurs och gå till Functions ->App keys ->System keys ->webpubsub_extension när du har distribuerat funktionsappen till Azure. Den här nyckeln behövs dock inte när du arbetar med lokala funktioner.

<Function_App_Url>/runtime/webhooks/webpubsub?code=<API_KEY>

Screenshot of get function system keys.

Exempel

[FunctionName("WebPubSubTrigger")]
public static void Run(
    [WebPubSubTrigger("<hub>", WebPubSubEventType.User, "message")] UserEventRequest request, ILogger log)
{
    log.LogInformation($"Request from: {request.ConnectionContext.UserId}");
    log.LogInformation($"Request message data: {request.Data}");
    log.LogInformation($"Request message dataType: {request.DataType}");
}

WebPubSubTrigger bindning stöder också returvärde i synkroniserade scenarier, till exempel system Connect - och användarhändelse, när servern kan kontrollera och neka klientbegäran eller skicka meddelanden direkt till anroparen. Connect händelse respekterar ConnectEventResponse och EventErrorResponse, och användarhändelse respekterar UserEventResponse och EventErrorResponse, vilotyper som inte matchar det aktuella scenariot ignoreras. Och om EventErrorResponse returneras släpper tjänsten klientanslutningen.

[FunctionName("WebPubSubTriggerReturnValueFunction")]
public static UserEventResponse Run(
    [WebPubSubTrigger("hub", WebPubSubEventType.User, "message")] UserEventRequest request)
{
    return request.CreateResponse(BinaryData.FromString("ack"), WebPubSubDataType.Text);
}

I följande exempel visas en JavaScript-funktion för Web PubSub-utlösare.

const { app, trigger } = require('@azure/functions');

const wpsTrigger = trigger.generic({
    type: 'webPubSubTrigger',
    name: 'request',
    hub: '<hub>',
    eventName: 'message',
    eventType: 'user'
});

app.generic('message', {
    trigger: wpsTrigger,
    handler: async (request, context) => {
        context.log('Request from: ', request.connectionContext.userId);
        context.log('Request message data: ', request.data);
        context.log('Request message dataType: ', request.dataType);
    }
});

WebPubSubTrigger bindning stöder även returvärde i synkroniserade scenarier, till exempel system Connect - och användarhändelse, när servern kan kontrollera och neka klientbegäran eller skicka ett meddelande direkt till begärandeklienten. I ett svagt skrivet JavaScript-språk är det deserialiserat när det gäller objektnycklarna. Och EventErrorResponse har den högsta prioriteten jämfört med vilande objekt, som om code är i returen, sedan parsas till EventErrorResponse och klientanslutningen tas bort.

app.generic('message', {
    trigger: wpsTrigger,
    handler: async (request, context) => {
          return { 
              "data": "ack",
              "dataType" : "text"
          };
    }
});

Definiera utlösarbindning i function.json.

{
  "disabled": false,
  "bindings": [
    {
      "type": "webPubSubTrigger",
      "direction": "in",
      "name": "data",
      "hub": "<hub>",
      "eventName": "message",
      "eventType": "user"
    }
  ]
}

Definiera funktionen i index.js.

module.exports = function (context, data) {
  context.log('Request from: ', context.bindingData.request.connectionContext.userId);
  context.log('Request message data: ', data);
  context.log('Request message dataType: ', context.bindingData.request.dataType);
}

module.exports = async function (context) {
  return { 
    "data": "ack",
    "dataType" : "text"
  };
}

Attribut och anteckningar

Använd attributet i C#-klassbibliotek.WebPubSubTrigger

Här är ett WebPubSubTrigger attribut i en metodsignatur:

[FunctionName("WebPubSubTrigger")]
public static void Run([WebPubSubTrigger("<hub>", <WebPubSubEventType>, "<event-name>")] 
    WebPubSubConnectionContext context, ILogger log)
{
    ...
}

Ett fullständigt exempel finns i C#-exempel.

Konfiguration

I följande tabell beskrivs de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json-egenskap	Attributegenskap	beskrivning
typ	saknas	Obligatoriskt – måste anges till `webPubSubTrigger`.
riktning	saknas	Obligatoriskt – måste anges till `in`.
Namn	saknas	Obligatoriskt – variabelnamnet som används i funktionskoden för parametern som tar emot händelsedata.
Nav	Hubb	Obligatoriskt – värdet måste anges till namnet på Web PubSub-hubben för att funktionen ska utlösas. Vi har stöd för att ange värdet i attributet som högre prioritet, eller så kan det anges i appinställningar som ett globalt värde.
Händelsetyp	WebPubSubEventType	Obligatoriskt – värdet måste anges som händelsetyp för meddelanden för att funktionen ska utlösas. Värdet ska vara antingen `user` eller `system`.
eventName	EventName	Obligatoriskt – värdet måste anges som händelse av meddelanden för att funktionen ska utlösas. För `system` händelsetyp ska händelsenamnet vara i `connect`, `connected`, `disconnected`. För användardefinierade subprotokoler är `message`händelsenamnet . För underprotokol `json.webpubsub.azure.v1.`som stöds av systemet är händelsenamnet användardefinierat händelsenamn.
Anslutning	Connection	Valfritt – namnet på en appinställningar eller inställningssamling som anger den överordnade Azure Web PubSub-tjänsten. Värdet används för signaturverifiering. Och värdet matchas automatiskt med appinställningarna "WebPubSub Anslut ionString" som standard. Och `null` innebär att valideringen inte behövs och alltid lyckas.

Användningsområden

I C# WebPubSubEventRequest är typen identifierad bindningsparameter, restparametrar är bundna av parameternamn. Kontrollera tabellen nedan med tillgängliga parametrar och typer.

I ett svagt skrivet språk som JavaScript name används i function.json för att binda utlösarobjektet för mappningstabellen nedan. Och respekt dataType för function.json att konvertera meddelandet i enlighet med detta när name är inställt data på som bindningsobjektet för utlösarindata. Alla parametrar kan läsas från context.bindingData.<BindingName> och JObject konverteras.

Bindningsnamn	Bindningstyp	beskrivning	Egenskaper
begäran	`WebPubSubEventRequest`	Beskriver den överordnade begäran	Egenskapen skiljer sig mellan olika händelsetyper, inklusive härledda klasser `ConnectEventRequest`, `ConnectedEventRequest`och `UserEventRequestDisconnectedEventRequest`
connectionContext	`WebPubSubConnectionContext`	Gemensam information om begäranden	EventType, EventName, Hub, Anslut ionId, UserId, Headers, Origin, Signature, States
data	`BinaryData`,`string`,`Stream`,`byte[]`	Begära meddelandedata från klienten i användarhändelse `message`	-
Datatyp	`WebPubSubDataType`	Begär meddelandedataType, som stöder `binary`, `text`, `json`	-
anspråk	`IDictionary<string, string[]>`	Användaranspråk i systembegäran `connect`	-
query	`IDictionary<string, string[]>`	Användarfråga i systembegäran `connect`	-
subprotocols	`IList<string>`	Tillgängliga delprotokoler i systembegäran `connect`	-
clientCertificates	`IList<ClientCertificate>`	En lista över tumavtryck för certifikat från klienter i systembegäran `connect`	-
orsak	`string`	Orsak i systembegäran `disconnected`	-

Viktigt!

I C# måste flera typer som stöds ange parametern MÅSTE placeras i den första, dvs. request eller data den andra än standardtypen BinaryData för att göra funktionen bindning korrekt.

Retursvar

WebPubSubTrigger respekterar kundens returnerade svar för synkrona händelser och connect användarhändelser. Endast matchat svar skickas tillbaka till tjänsten, annars ignoreras det. Dessutom stöder returneringsobjekt WebPubSubTrigger användare till SetState() och ClearStates() för att hantera metadata för anslutningen. Och tillägget sammanfogar resultatet från returvärdet med de ursprungliga från begäran WebPubSubConnectionContext.States. Värdet i den befintliga nyckeln skrivs över och värdet i den nya nyckeln läggs till.

Returtyp	beskrivning	Egenskaper
`ConnectEventResponse`	Svar för `connect` händelse	Grupper, roller, UserId, Subprotocol
`UserEventResponse`	Svar för användarhändelse	DataType, Data
`EventErrorResponse`	Felsvar för synkroniseringshändelsen	Kod, ErrorMessage
`*WebPubSubEventResponse`	Bassvarstyp för de som stöds och som används för osäkra returärenden	-

Indatabindning

Vårt tillägg innehåller två indatabindningar som riktar sig till olika behov.

WebPubSubConnection

För att en klient ska kunna ansluta till Azure Web PubSub Service måste den känna till tjänstens slutpunkts-URL och en giltig åtkomsttoken. Indatabindningen WebPubSubConnection genererar nödvändig information, så klienten behöver inte hantera själva tokengenereringen. Eftersom token är tidsbegränsad och kan användas för att autentisera en specifik användare till en anslutning, cachelagra inte token eller dela den mellan klienter. En HTTP-utlösare som arbetar med den här indatabindningen kan användas för klienter för att hämta anslutningsinformationen.
WebPubSubContext

När du använder är Static Web Apps, HttpTrigger är den enda utlösare som stöds och under Web PubSub-scenariot tillhandahåller WebPubSubContext vi indatabindningen som hjälper användare att deserialisera uppströms http-begäran från tjänstsidan under Web PubSub-protokoll. Så att kunderna kan få liknande resultat jämfört med WebPubSubTrigger för att enkelt hantera i funktioner. Se exempel nedan. När den används med måste kunden konfigurera den HttpTrigger-exponerade URL:en i händelsehanteraren i enlighet med HttpTriggerdetta.

Exempel- `WebPubSubConnection`

I följande exempel visas en C#-funktion som hämtar anslutningsinformation för Web PubSub med hjälp av indatabindningen och returnerar den via HTTP. I exemplet nedan skickas UserId den via frågedelen för klientbegäran som ?userid={User-A}.

[FunctionName("WebPubSubConnectionInputBinding")]
public static WebPubSubConnection Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req,
    [WebPubSubConnection(Hub = "<hub>", UserId = "{query.userid}")] WebPubSubConnection connection)
{
    return connection;
}

const { app, input } = require('@azure/functions');

const connection = input.generic({
    type: 'webPubSubConnection',
    name: 'connection',
    userId: '{query.userId}',
    hub: '<hub>'
});

app.http('negotiate', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    extraInputs: [connection],
    handler: async (request, context) => {
        return { body: JSON.stringify(context.extraInputs.get('connection')) };
    },
});

Definiera indatabindningar i function.json.

{
  "disabled": false,
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "webPubSubConnection",
      "name": "connection",
      "userId": "{query.userid}",
      "hub": "<hub>",
      "direction": "in"
    }
  ]
}

Definiera funktionen i index.js.

module.exports = function (context, req, connection) {
  context.res = { body: connection };
  context.done();
};

Autentiserade token

Om funktionen utlöses av en autentiserad klient kan du lägga till ett användar-ID-anspråk till den genererade token. Du kan enkelt lägga till autentisering i en funktionsapp med App Service-autentisering.

App Service-autentisering anger HTTP-huvuden med namnet x-ms-client-principal-id och x-ms-client-principal-name som innehåller den autentiserade användarens klienthuvudnamn respektive namn.

Du kan ange egenskapen UserId för bindningen till värdet från antingen huvudet med ett bindningsuttryck: {headers.x-ms-client-principal-id} eller {headers.x-ms-client-principal-name}.

[FunctionName("WebPubSubConnectionInputBinding")]
public static WebPubSubConnection Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req,
    [WebPubSubConnection(Hub = "<hub>", UserId = "{headers.x-ms-client-principal-name}")] WebPubSubConnection connection)
{
    return connection;
}

Kommentar

Begränsad till bindningsparametertyper stöder inte ett sätt att skicka lista eller matris, WebPubSubConnection stöds inte fullt ut med alla parametrar som server-SDK:t har, särskilt roles, och inkluderar groups och expiresAfter. Om kunden behöver lägga till roller eller fördröja genereringen av åtkomsttoken i funktionen rekommenderar vi att du arbetar med server-SDK för C#.

[FunctionName("WebPubSubConnectionCustomRoles")]
public static async Task<Uri> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req)
{
    var serviceClient = new WebPubSubServiceClient(new Uri(endpoint), "<hub>", "<web-pubsub-connection-string>");
    var userId = req.Query["userid"].FirstOrDefault();
    // your method to get custom roles.
    var roles = GetRoles(userId);
    return await serviceClient.GetClientAccessUriAsync(TimeSpan.FromMinutes(5), userId, roles);
}

Kommentar

const { app } = require('@azure/functions');
const { WebPubSubServiceClient } = require('@azure/web-pubsub');
app.http('negotiate', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        const serviceClient = new WebPubSubServiceClient(process.env.WebPubSubConnectionString, "<hub>");
        let token = await serviceClient.getAuthenticationToken({ userId: req.query.userid, roles: ["webpubsub.joinLeaveGroup", "webpubsub.sendToGroup"] });
        return { body: token.url };
    },
});

Kommentar

Definiera indatabindningar i function.json.

{
  "disabled": false,
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ]
}

Definiera funktionen i index.js.

const { WebPubSubServiceClient } = require('@azure/web-pubsub');

module.exports = async function (context, req) {
  const serviceClient = new WebPubSubServiceClient(process.env.WebPubSubConnectionString, "<hub>");
  let token = await serviceClient.getAuthenticationToken({ userId: req.query.userid, roles: ["webpubsub.joinLeaveGroup", "webpubsub.sendToGroup"] });
  context.res = { body: token.url };
  context.done();
};

Exempel- `WebPubSubContext`

I följande exempel visas en C#-funktion som hämtar information om Web PubSub-överordnad begäran med hjälp av indatabindningen under connect händelsetyp och returnerar den via HTTP.

[FunctionName("WebPubSubContextInputBinding")]
public static object Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req,
    [WebPubSubContext] WebPubSubContext wpsContext)
{
    // in the case request is a preflight or invalid, directly return prebuild response by extension.
    if (wpsContext.IsPreflight || wpsContext.HasError)
    {
        return wpsContext.Response;
    }
    var request = wpsContext.Request as ConnectEventRequest;
    var response = new ConnectEventResponse
    {
        UserId = wpsContext.Request.ConnectionContext.UserId
    };
    return response;
}

const { app, input } = require('@azure/functions');

const wpsContext = input.generic({
    type: 'webPubSubContext',
    name: 'wpsContext'
});

app.http('connect', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    extraInputs: [wpsContext],
    handler: async (request, context) => {
        var wpsRequest = context.extraInputs.get('wpsContext');

        return { "userId": wpsRequest.request.connectionContext.userId };
    }
});

Definiera indatabindningar i function.json.

{
  "disabled": false,
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "webPubSubContext",
      "name": "wpsContext",
      "direction": "in"
    }
  ]
}

Definiera funktionen i index.js.

module.exports = async function (context, req, wpsContext) {
  // in the case request is a preflight or invalid, directly return prebuild response by extension.
  if (wpsContext.hasError || wpsContext.isPreflight)
  {
    return wpsContext.response;
  }
  // return an http response with connect event response as body.
  return { body: {"userId": wpsContext.connectionContext.userId} };
};

Konfiguration

WebPubSub Anslut ion

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json och WebPubSubConnection attributet.

function.json-egenskap	Attributegenskap	beskrivning
typ	saknas	Måste anges till `webPubSubConnection`
riktning	saknas	Måste anges till `in`
Namn	saknas	Variabelnamn som används i funktionskoden för indataanslutningsbindningsobjekt.
Nav	Hubb	Obligatoriskt – Värdet måste anges till namnet på Web PubSub-hubben för att funktionen ska utlösas. Vi har stöd för att ange värdet i attributet som högre prioritet, eller så kan det anges i appinställningar som ett globalt värde.
Userid	AnvändarID	Valfritt – värdet för det anspråk för användaridentifierare som ska anges i åtkomstnyckeltoken.
Anslutning	Connection	Obligatoriskt – namnet på appinställningen som innehåller Web PubSub Service-anslutningssträng (standardvärdet är "WebPubSub Anslut ionString").

WebPubSubContext

I följande tabell beskrivs de bindningskonfigurationsegenskaper som du anger i filen functions.json och WebPubSubContext attributet.

function.json-egenskap	Attributegenskap	beskrivning
typ	saknas	Måste anges till `webPubSubContext`.
riktning	saknas	Måste anges till `in`.
Namn	saknas	Variabelnamn som används i funktionskoden för indata för Web PubSub-begäran.
Anslutning	Connection	Valfritt – namnet på en appinställningar eller inställningssamling som anger den överordnade Azure Web PubSub-tjänsten. Värdet används för verifiering av missbruksskydd och signaturer. Värdet matchas automatiskt med "WebPubSub Anslut ionString" som standard. Och `null` innebär att valideringen inte behövs och alltid lyckas.

Användning

WebPubSub Anslut ion

WebPubSubConnection innehåller egenskaperna nedan.

Bindningsnamn	Bindningstyp	beskrivning
BaseUri	Uri	Web PubSub-klientanslutnings-URI.
Uri	Uri	Absolut URI för Web PubSub-anslutningen, innehåller `AccessToken` genererad bas på begäran.
AccessToken	sträng	Genereras `AccessToken` baserat på begäranDet användar-ID och tjänstinformation.

WebPubSubConnection innehåller egenskaperna nedan.

Bindningsnamn	beskrivning
baseUrl	Web PubSub-klientanslutnings-URI.
URL	Absolut URI för Web PubSub-anslutningen, innehåller `AccessToken` genererad bas på begäran.
accessToken	Genereras `AccessToken` baserat på begäranDet användar-ID och tjänstinformation.

WebPubSubConnection innehåller egenskaperna nedan.

Bindningsnamn	beskrivning
baseUrl	Web PubSub-klientanslutnings-URI.
URL	Absolut URI för Web PubSub-anslutningen, innehåller `AccessToken` genererad bas på begäran.
accessToken	Genereras `AccessToken` baserat på begäranDet användar-ID och tjänstinformation.

WebPubSubContext

WebPubSubContext innehåller egenskaperna nedan.

Bindningsnamn	Bindningstyp	beskrivning	Egenskaper
begäran	`WebPubSubEventRequest`	Begäran från klienten finns i tabellen nedan för mer information.	`WebPubSubConnectionContext` från begärandehuvudet och andra egenskaper som deserialiserats från begärandetexten beskriver begäran, till exempel `Reason` för `DisconnectedEventRequest`.
svar	`HttpResponseMessage`	Tillägget bygger svar främst för `AbuseProtection` och felfall.	-
errorMessage	sträng	Beskriv felinformationen när du bearbetar den överordnade begäran.	-
hasError	bool	Flagga för att ange om det är en giltig Web PubSub-begäran överordnad.	-
isPreflight	bool	Flagga för att ange om det är en förhandsbegäran av `AbuseProtection`.	-

För WebPubSubEventRequestär den deserialiserad till olika klasser som ger olika information om begärandescenariot. För PreflightRequest eller inte giltiga fall kan användaren kontrollera flaggorna IsPreflight och HasError veta. Vi föreslår att du returnerar systemversionssvaret WebPubSubContext.Response direkt, eller så kan kunden logga fel på begäran. I olika scenarier kan kunden läsa egenskaperna för begäran enligt nedan.

Härledd klass	beskrivning	Egenskaper
`PreflightRequest`	Används i `AbuseProtection` när `IsPreflight` är sant	-
`ConnectEventRequest`	Används i systemhändelsetyp `Connect`	Claims, Query, Subprotocols, ClientCertificates
`ConnectedEventRequest`	Används i systemhändelsetyp `Connected`	-
`UserEventRequest`	Används i händelsetyp för användare	Data, DataType
`DisconnectedEventRequest`	Används i systemhändelsetyp `Disconnected`	Anledning

Kommentar

WebPubSubContext Även om är en indatabindning ger liknande begärandeserialisera sätt under HttpTrigger jämförelse med WebPubSubTrigger, finns det begränsningar, dvs. anslutningstillstånd efter sammanslagning stöds inte. Retursvaret respekteras fortfarande av tjänstsidan, men användarna måste själva skapa svaret. Om användarna behöver ange händelsesvaret bör du returnera en HttpResponseMessage contains eller meddelanden för användarhändelsen som svarstext och ange anslutningstillstånd med nyckeln ce-connectionstate i svarshuvudetConnectEventResponse.

Utdatabindning

Använd utdatabindningen Web PubSub för att anropa Azure Web PubSub-tjänsten för att göra något. Du kan sända ett meddelande till:

Alla anslutna klienter
Anslut klienter som autentiserats för en viss användare
Anslut klienter som är anslutna i en specifik grupp
En specifik klientanslutning

Med utdatabindningen kan du också hantera klienter och grupper, samt bevilja/återkalla behörigheter för specifika connectionId med grupp.

Lägg till anslutning till grupp
Lägg till användare i grupp
Ta bort anslutningen från en grupp
Ta bort användare från en grupp
Ta bort användare från alla grupper
Stäng alla klientanslutningar
Stäng en specifik klientanslutning
Stänga anslutningar i en grupp
Bevilja behörighet för en anslutning
Återkalla behörighet för en anslutning

Information om konfiguration och konfigurationsinformation finns i översikten.

Exempel

[FunctionName("WebPubSubOutputBinding")]
public static async Task RunAsync(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req,
    [WebPubSub(Hub = "<hub>")] IAsyncCollector<WebPubSubAction> actions)
{
    await actions.AddAsync(WebPubSubAction.CreateSendToAllAction("Hello Web PubSub!", WebPubSubDataType.Text));
}

const { app, output } = require('@azure/functions');
const wpsMsg = output.generic({
    type: 'webPubSub',
    name: 'actions',
    hub: '<hub>',
});

app.http('message', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    extraOutputs: [wpsMsg],
    handler: async (request, context) => {
        context.extraOutputs.set(wpsMsg, [{
            "actionName": "sendToAll",
            "data": `Hello world`,
            "dataType": `text`
        }]);
    }
});

Definiera bindningar i functions.json.

{
  "disabled": false,
  "bindings": [
    {
      "type": "webPubSub",
      "name": "actions",
      "hub": "<hub>",
      "direction": "out"
    }
  ]
}

Definiera funktionen i index.js.

module.exports = async function (context) {
  context.bindings.actions = {
    "actionName": "sendToAll",
    "data": "hello",
    "dataType": "text"
  };
  context.done();
}

WebPubSubAction

WebPubSubAction är den grundläggande abstrakta typen av utdatabindningar. De härledda typerna representerar åtgärdsservern som vill att tjänsten ska anropas.

På C#-språket tillhandahåller vi några statiska metoder under WebPubSubAction för att identifiera tillgängliga åtgärder. Användaren kan till exempel skapa per-anropet SendToAllActionWebPubSubAction.CreateSendToAllAction().

Härledd klass	Egenskaper
`SendToAllAction`	Data, DataType, Exkluderade
`SendToGroupAction`	Grupp, Data, DataType, Exkluderad
`SendToUserAction`	UserId, Data, DataType
`SendToConnectionAction`	Anslut ionId, Data, DataType
`AddUserToGroupAction`	UserId, Grupp
`RemoveUserFromGroupAction`	UserId, Grupp
`RemoveUserFromAllGroupsAction`	AnvändarID
`AddConnectionToGroupAction`	Anslut ionId, Grupp
`RemoveConnectionFromGroupAction`	Anslut ionId, Grupp
`CloseAllConnectionsAction`	Exkluderad, orsak
`CloseClientConnectionAction`	Anslut ionId, orsak
`CloseGroupConnectionsAction`	Grupp, Exkluderad, Orsak
`GrantPermissionAction`	Anslut ionId, Behörighet, TargetName
`RevokePermissionAction`	Anslut ionId, Behörighet, TargetName

I ett svagt skrivet språk som javascript, actionName är nyckelparametern för att lösa typen visas tillgängliga åtgärder enligt nedan.

ActionName	Egenskaper
`sendToAll`	Data, DataType, Exkluderade
`sendToGroup`	Grupp, Data, DataType, Exkluderad
`sendToUser`	UserId, Data, DataType
`sendToConnection`	Anslut ionId, Data, DataType
`addUserToGroup`	UserId, Grupp
`removeUserFromGroup`	UserId, Grupp
`removeUserFromAllGroups`	AnvändarID
`addConnectionToGroup`	Anslut ionId, Grupp
`removeConnectionFromGroup`	Anslut ionId, Grupp
`closeAllConnections`	Exkluderad, orsak
`closeClientConnection`	Anslut ionId, orsak
`closeGroupConnections`	Grupp, Exkluderad, Orsak
`grantPermission`	Anslut ionId, Behörighet, TargetName
`revokePermission`	Anslut ionId, Behörighet, TargetName

Viktigt!

Meddelandedataegenskapen i åtgärderna för att skicka meddelanden måste vara string om datatypen är inställd på json eller text för att undvika tvetydigheter i datakonverteringen. Använd JSON.stringify() för att konvertera det json-objekt som behövs. Detta tillämpas på valfri plats med hjälp av meddelandeegenskapen, UserEventResponse.Data till exempel när du arbetar med WebPubSubTrigger.

När datatypen är inställd på binaryfår den använda bindning som stöds dataType naturligt enligt binary konfigurationen function.jsoni , se Utlösar- och bindningsdefinitioner för mer information.

I ett svagt skrivet språk som javascript, actionName är nyckelparametern för att lösa typen visas tillgängliga åtgärder enligt nedan.

ActionName	Egenskaper
`sendToAll`	Data, DataType, Exkluderade
`sendToGroup`	Grupp, Data, DataType, Exkluderad
`sendToUser`	UserId, Data, DataType
`sendToConnection`	Anslut ionId, Data, DataType
`addUserToGroup`	UserId, Grupp
`removeUserFromGroup`	UserId, Grupp
`removeUserFromAllGroups`	AnvändarID
`addConnectionToGroup`	Anslut ionId, Grupp
`removeConnectionFromGroup`	Anslut ionId, Grupp
`closeAllConnections`	Exkluderad, orsak
`closeClientConnection`	Anslut ionId, orsak
`closeGroupConnections`	Grupp, Exkluderad, Orsak
`grantPermission`	Anslut ionId, Behörighet, TargetName
`revokePermission`	Anslut ionId, Behörighet, TargetName

Viktigt!

Konfiguration

WebPubSub

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json och WebPubSub attributet.

function.json-egenskap	Attributegenskap	beskrivning
typ	saknas	Måste anges till `webPubSub`
riktning	saknas	Måste anges till `out`
Namn	saknas	Variabelnamn som används i funktionskoden för utdatabindningsobjekt.
Nav	Hubb	Värdet måste anges till namnet på Web PubSub-hubben för att funktionen ska utlösas. Vi har stöd för att ange värdet i attributet som högre prioritet, eller så kan det anges i appinställningar som ett globalt värde.
Anslutning	Connection	Namnet på appinställningen som innehåller Web PubSub Service-anslutningssträng (standardvärdet är "WebPubSub Anslut ionString").