Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Definieren Sie erweiterte Abonnementfilter in AWS AppSync

In AWS AppSync können Sie die Geschäftslogik für die Datenfilterung im Backend direkt in den GraphQL-API-Abonnement-Resolvern definieren und aktivieren, indem Sie Filter verwenden, die zusätzliche logische Operatoren unterstützen. Im Gegensatz zu den Abonnementargumenten, die in der Abonnementabfrage im Client definiert sind, können Sie diese Filter konfigurieren. Weitere Hinweise zur Verwendung von Abonnementargumenten finden Sie unterVerwenden von Abonnement-Argumenten. Eine Liste der Operatoren finden Sie unterAWS AppSync Referenz zum Hilfsprogramm für Resolver-Mapping-Vorlagen.

Für die Zwecke dieses Dokuments unterteilen wir die Echtzeit-Datenfilterung in die folgenden Kategorien:

In den folgenden Abschnitten wird erklärt, wie erweiterte Abonnementfilter konfiguriert werden und wie sie in der Praxis eingesetzt werden.

Definieren Sie Abonnements in Ihrem GraphQL-Schema

Um erweiterte Abonnementfilter zu verwenden, definieren Sie das Abonnement im GraphQL-Schema und definieren dann den erweiterten Filter mithilfe einer Filtererweiterung. Verwenden Sie als Beispiel das folgende GraphQL-Schema AWS AppSync, das eine Ticketverwaltungssystem-API definiert, um zu veranschaulichen, wie die erweiterte Abonnementfilterung funktioniert:

type Ticket {
	id: ID
	createdAt: AWSDateTime
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	status: String
	
}

type Mutation {
	createTicket(input: TicketInput): Ticket
}

type Query {
	getTicket(id: ID!): Ticket
}

type Subscription {
	onSpecialTicketCreated: Ticket @aws_subscribe(mutations: ["createTicket"])
	onGroupTicketCreated(group: String!): Ticket @aws_subscribe(mutations: ["createTicket"])
}



enum Priority {
	none
	lowest
	low
	medium
	high
	highest
}

input TicketInput {
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	

Angenommen, Sie erstellen eine NONE Datenquelle für Ihre API und hängen dann mithilfe dieser Datenquelle einen Resolver an die createTicket Mutation an. Ihre Handler könnten so aussehen:

import { util } from '@aws-appsync/utils';

export function request(ctx) {
	return {
		payload: {
			id: util.autoId(),
			createdAt: util.time.nowISO8601(),
			status: 'pending',
			...ctx.args.input,
		},
	};
}

export function response(ctx) {
	return ctx.result;
}

Um das Verhalten des erweiterten Filters zu implementieren, müssen Sie die extensions.setSubscriptionFilter() Funktion verwenden, um einen Filterausdruck zu definieren, der anhand veröffentlichter Daten einer GraphQL-Mutation ausgewertet wird, an der die abonnierten Clients interessiert sein könnten. Weitere Informationen zu den Filtererweiterungen finden Sie unter Erweiterungen.

Im folgenden Abschnitt wird erklärt, wie Sie Filtererweiterungen verwenden, um erweiterte Filter zu implementieren.

Erstellen erweiterter Abonnementfilter mithilfe von Filtererweiterungen

Erweiterte Filter werden in JSON in den Response-Handler der Resolver des Abonnements geschrieben. Filter können in einer Liste namens a filterGroup gruppiert werden. Filter werden mithilfe von mindestens einer Regel definiert, die jeweils Felder, Operatoren und Werte enthält. Lassen Sie uns einen neuen Resolver definierenonSpecialTicketCreated, der einen erweiterten Filter einrichtet. Sie können mehrere Regeln in einem Filter konfigurieren, die mithilfe der UND-Logik ausgewertet werden, während mehrere Filter in einer Filtergruppe mithilfe der OR-Logik ausgewertet werden:

import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = {
		or: [
			{ severity: { ge: 7 }, priority: { in: ['high', 'medium'] } },
			{ category: { eq: 'security' }, group: { in: ['admin', 'operators'] } },
		],
	};
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));

  // important: return null in the response
	return null;
}

Basierend auf den im vorherigen Beispiel definierten Filtern werden wichtige Tickets automatisch an abonnierte API-Clients weitergeleitet, wenn ein Ticket erstellt wird mit:

ODER

Im Abonnement-Resolver definierte Filter (erweiterte Filterung) haben Vorrang vor Filtern, die nur auf Abonnementargumenten basieren (einfache Filterung). Weitere Informationen zur Verwendung von Abonnementargumenten finden Sie unter Abonnementargumente https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html#using-subscription-arguments verwenden).

Wenn ein Argument im GraphQL-Schema des Abonnements definiert und erforderlich ist, erfolgt die Filterung auf der Grundlage des angegebenen Arguments nur, wenn das Argument in der Methode des Resolvers als Regel definiert istextensions.setSubscriptionFilter(). Wenn der Abonnement-Resolver jedoch keine extensions Filtermethoden enthält, werden die im Client definierten Argumente nur für die grundlegende Filterung verwendet. Sie können die einfache Filterung und die erweiterte Filterung nicht gleichzeitig verwenden.

Sie können die context Variable in der Filtererweiterungslogik des Abonnements verwenden, um auf kontextbezogene Informationen zur Anfrage zuzugreifen. Wenn Sie beispielsweise benutzerdefinierte Amazon Cognito-Benutzerpools, OIDC oder Lambda-Autorisierer für die Autorisierung verwenden, können Sie Informationen über Ihre Benutzer abrufen, wenn das Abonnement eingerichtet wird. context.identity Sie können diese Informationen verwenden, um Filter einzurichten, die auf der Identität Ihrer Benutzer basieren.

Gehen Sie nun davon aus, dass Sie das erweiterte Filterverhalten für implementieren möchtenonGroupTicketCreated. Das onGroupTicketCreated Abonnement erfordert einen obligatorischen group Namen als Argument. Bei der Erstellung wird Tickets automatisch ein pending Status zugewiesen. Sie können einen Abonnementfilter einrichten, um nur neu erstellte Tickets zu erhalten, die zur angegebenen Gruppe gehören:

import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = { group: { eq: ctx.args.group }, status: { eq: 'pending' } };
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));

	return null;
}

Wenn Daten mithilfe einer Mutation wie im folgenden Beispiel veröffentlicht werden:

mutation CreateTicket {
  createTicket(input: {priority: medium, severity: 2, group: "aws"}) {
    id
    priority
    severity
    status
    group
    createdAt
  }
}

Abonnierte Kunden warten darauf, dass die Daten automatisch weitergeleitet werden, WebSockets sobald ein Ticket mit der createTicket Mutation erstellt wird:

subscription OnGroup {
  onGroupTicketCreated(group: "aws") {
    category
    status
    severity
    priority
    id
    group
    createdAt
    content
  }
}

Kunden können ohne Argumente abonniert werden, da die Filterlogik im AWS AppSync Service mit erweiterter Filterung implementiert ist, was den Client-Code vereinfacht. Clients erhalten nur Daten, wenn die definierten Filterkriterien erfüllt sind.

Definition erweiterter Filter für verschachtelte Schemafelder

Sie können die erweiterte Abonnementfilterung verwenden, um verschachtelte Schemafelder zu filtern. Angenommen, wir haben das Schema aus dem vorherigen Abschnitt geändert, um Standort- und Adresstypen einzubeziehen:

type Ticket {
	id: ID
	createdAt: AWSDateTime
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	status: String
	location: ProblemLocation
}

type Mutation {
	createTicket(input: TicketInput): Ticket
}

type Query {
	getTicket(id: ID!): Ticket
}

type Subscription {
	onSpecialTicketCreated: Ticket @aws_subscribe(mutations: ["createTicket"])
	onGroupTicketCreated(group: String!): Ticket @aws_subscribe(mutations: ["createTicket"])
}

type ProblemLocation {
	address: Address
}

type Address {
	country: String
}

enum Priority {
	none
	lowest
	low
	medium
	high
	highest
}

input TicketInput {
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	location: AWSJSON

Mit diesem Schema können Sie ein . Trennzeichen verwenden, um Verschachtelungen darzustellen. Im folgenden Beispiel wird eine Filterregel für ein verschachteltes Schemafeld unter hinzugefügt. location.address.country Das Abonnement wird ausgelöst, wenn die Adresse des Tickets wie folgt festgelegt ist: USA

import { util, extensions } from '@aws-appsync/utils';

export const request = (ctx) => ({ payload: null });

export function response(ctx) {
	const filter = {
		or: [
			{ severity: { ge: 7 }, priority: { in: ['high', 'medium'] } },
			{ category: { eq: 'security' }, group: { in: ['admin', 'operators'] } },
			{ 'location.address.country': { eq: 'USA' } },
		],
	};
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));
	return null;
}

Im obigen Beispiel location steht es für Verschachtelungsebene eins, address für Verschachtelungsebene zwei und country für Verschachtelungsebene drei, die alle durch ein Trennzeichen getrennt sind. .

Sie können dieses Abonnement testen, indem Sie die folgende Mutation verwenden: createTicket

mutation CreateTicketInUSA {
  createTicket(input: {location: "{\"address\":{\"country\":\"USA\"}}"}) {
    category
    content
    createdAt
    group
    id
    location {
      address {
        country
      }
    }
    priority
    severity
    status
  }
}

Definition erweiterter Filter vom Client aus

Sie können die grundlegende Filterung in GraphQL mit Abonnementargumenten verwenden. Der Client, der den Aufruf in der Abonnementabfrage tätigt, definiert die Werte der Argumente. Wenn erweiterte Filter in einem AWS AppSync Abonnement-Resolver zusammen mit der extensions Filterung aktiviert sind, haben die im Resolver definierten Backend-Filter Vorrang und Priorität.

Konfigurieren Sie dynamische, vom Client definierte erweiterte Filter mithilfe eines Arguments im Abonnement. filter Wenn Sie diese Filter konfigurieren, müssen Sie das GraphQL-Schema aktualisieren, um das neue Argument widerzuspiegeln:

...
type Subscription {
    onSpecialTicketCreated(filter: String): Ticket
        @aws_subscribe(mutations: ["createTicket"])
}
...

Der Client kann dann eine Abonnementabfrage wie im folgenden Beispiel senden:

subscription onSpecialTicketCreated($filter: String) {
     onSpecialTicketCreated(filter: $filter) {
        id
        group
        description
        priority
        severity
     }
 }

Sie können die Abfragevariable wie im folgenden Beispiel konfigurieren:

{"filter" : "{\"severity\":{\"le\":2}}"}

Das util.transform.toSubscriptionFilter() Resolver-Hilfsprogramm kann in die Vorlage für die Zuordnung von Abonnementantworten implementiert werden, um den im Abonnement-Argument definierten Filter auf jeden Client anzuwenden:

import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = ctx.args.filter;
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));
	return null;
}

Mit dieser Strategie können Kunden ihre eigenen Filter definieren, die eine erweiterte Filterlogik und zusätzliche Operatoren verwenden. Filter werden zugewiesen, wenn ein bestimmter Client die Abonnementabfrage über eine sichere WebSocket Verbindung aufruft. Weitere Informationen zum Transformationsprogramm für erweiterte Filterung, einschließlich des Formats der Nutzlast der filter Abfragevariablen, finden Sie unter Überblick über JavaScript Resolver.

Zusätzliche erweiterte Filtereinschränkungen

Im Folgenden sind einige Anwendungsfälle aufgeführt, in denen erweiterte Filter zusätzlich eingeschränkt werden: