JSON-Webtokens
Mit Sammlungen den Überblick behalten
Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.
Ein JSON Web Token (JWT) ist ein offener Webstandard, der zur Authentifizierung und Autorisierung des Informationsaustauschs zwischen einem Client und einem Server verwendet wird. Wenn sich ein App-Nutzer zum ersten Mal mit den entsprechenden Rollenanmeldedaten anmeldet, erstellt der Server ein codiertes, digital signiertes JWT und gibt es für die Verwendung mit nachfolgenden Anfragen zurück.
Bei diesem Vorgang wird der Nutzer sowohl authentifiziert als auch autorisiert, basierend auf seiner Kontorolle auf Routen, Dienste und Ressourcen zuzugreifen.
Für API-Methodenaufrufe aus Umgebungen mit geringem Vertrauensniveau (Smartphones und Browser) ist in Fleet Engine die Verwendung von JSON-Webtokens (JWTs) erforderlich.
Ein JWT wird auf Ihrem Server erstellt, signiert, verschlüsselt und an den Client übergeben. Es wird für nachfolgende Serverinteraktionen verwendet, bis es abläuft oder nicht mehr gültig ist.
Wichtige Details
Im Gegensatz zu API-Schlüsseln sind JWTs kurzlebig und beschränken Vorgänge auf diejenigen, die von der Rolle ausgeführt werden dürfen. Weitere Informationen zu JWTs finden Sie auf Wikipedia unter JSON Web Tokens. Weitere Informationen zu Zugriffsrollen finden Sie in diesem Leitfaden unter Dienstkontenrollen.
JWT-Elemente
JWTs enthalten einen Header und einen Anspruchsbereich. Der Header-Abschnitt enthält Informationen wie den privaten Schlüssel, der von Dienstkonten abgerufen wurde, und den Verschlüsselungsalgorithmus. Der Anspruchsbereich enthält Informationen wie die Erstellungszeit des JWT, die Gültigkeitsdauer, die Dienste, für die das JWT Zugriff beansprucht, und andere Autorisierungsinformationen zur Eingrenzung des Zugriffs, z. B. die ID des Lieferfahrzeugs.
Die folgende Tabelle enthält allgemeine beschreibende Details zu JWT-Feldern sowie spezifische Informationen dazu, wo Sie die Werte für diese Felder in Ihrem Fleet Engine-Cloud-Projekt finden.
JWT-Headerfelder
Feld |
Beschreibung |
alg |
Der zu verwendende Algorithmus. `RS256`. |
typ |
Der Typ des Tokens. `JWT`. |
Kind |
Die ID des privaten Schlüssels Ihres Dienstkontos. Sie finden diesen Wert im Feld private_key_id Ihrer JSON-Datei für das Dienstkonto. Verwenden Sie einen Schlüssel von einem Dienstkonto mit der richtigen Berechtigungsstufe. |
Felder für JWT-Anforderungen
Feld |
Beschreibung |
iss |
Die E-Mail-Adresse Ihres Dienstkontos, die Sie im Feld client_email Ihrer JSON-Datei für das Dienstkonto finden. |
Substitute |
Die E-Mail-Adresse Ihres Dienstkontos, die Sie im Feld client_email Ihrer JSON-Datei für das Dienstkonto finden. |
aud |
Die SERVICE_NAME Ihres Dienstkontos, in diesem Fall https://fleetengine.googleapis.com/ |
iat |
Der Zeitstempel, zu dem das JWT erstellt wurde, angegeben in Sekunden seit 00:00:00 UTC, January 1, 1970. Rechnen Sie rund 10 Minuten Verzögerung ein.
Wenn der Zeitstempel zu weit in der Vergangenheit oder in der Zukunft liegt, meldet der Server möglicherweise einen Fehler. |
exp |
Der Zeitstempel, wann das JWT abläuft, angegeben in Sekunden seit 00:00:00 UTC, January 1, 1970. Die Anfrage schlägt fehl, wenn der Zeitstempel mehr als eine Stunde in der Zukunft liegt. |
Autorisierung |
Je nach Anwendungsfall kann deliveryvehicleid, trackingid, taskid oder taskids enthalten sein.
Wenn Sie „taskids“ angeben, muss der Autorisierungsbereich ein Array in einem der folgenden Formate sein:
"taskids": ["task_id_one","task_id_two"]
oder
"taskids": ["*"] |
Fleet Engine-JWT-Anforderungen
Fleet Engine verwendet private Ansprüche. Durch die Verwendung privater Ansprüche wird sichergestellt, dass nur autorisierte Clients auf ihre eigenen Daten zugreifen können.
Wenn Ihr Server beispielsweise ein JSON Web Token für das Mobilgerät eines Fahrers ausstellt, sollte es entweder die vehicleid-Anforderung oder die deliveryvehicleid-Anforderung mit dem Wert der Fahrzeug-ID dieses Fahrers enthalten. Je nach Fahrerrolle ermöglichen JWTs dann nur den Zugriff auf die jeweilige Fahrzeug-ID und nicht auf eine beliebige andere Fahrzeug-ID.
Fleet Engine verwendet die folgenden privaten Ansprüche:
On-Demand-Fahrten
-
vehicleid:
- Das Driver SDK verwendet diesen Anspruch immer, unabhängig davon, ob es sich auf eine Fahrt oder ein Fahrzeug bezieht. Das Fleet Engine-Backend sorgt dafür, dass das Fahrzeug dem angeforderten Trip zugeordnet ist, bevor die Änderung vorgenommen wird.
-
Das JWT kann sowohl Fahrzeug- als auch Fahrtenvorgänge abdecken, auch wenn dies nicht erforderlich ist. Das kann die Implementierung der JWT-Signierung vereinfachen.
-
tripid:
- Das Consumer SDK verwendet diesen Anspruch immer.
-
Das JWT kann sowohl Fahrzeug- als auch Fahrtenvorgänge abdecken, auch wenn dies nicht erforderlich ist. Dies kann die Implementierung der Tokensignierung vereinfachen.
Geplante Aufgaben
-
deliveryvehicleid
Wird beim Aufrufen von APIs pro Lieferfahrzeug verwendet.
-
taskid
Wird beim Aufrufen von APIs für einzelne Aufgaben verwendet.
-
taskids
Wird beim Anrufen von BatchCreateTasksAPI verwendet. Dieser Anspruch muss in Arrayform vorliegen und das Array sollte alle Aufgaben-IDs enthalten, die zum Ausführen der Anfrage erforderlich sind. Fügen Sie keine Ansprüche für delivervehicleid, trackingid oder taskid hinzu.
-
trackingid
Wird beim Aufrufen der GetTaskTrackingInfoAPI verwendet. Die Anspruchs-ID muss mit der Tracking-ID in der Anfrage übereinstimmen. Fügen Sie keine Ansprüche für delivervehicleid, taskid oder taskids hinzu.
Nächste Schritte
Sofern nicht anders angegeben, sind die Inhalte dieser Seite unter der Creative Commons Attribution 4.0 License und Codebeispiele unter der Apache 2.0 License lizenziert. Weitere Informationen finden Sie in den Websiterichtlinien von Google Developers. Java ist eine eingetragene Marke von Oracle und/oder seinen Partnern.
Zuletzt aktualisiert: 2025-09-05 (UTC).
[[["Leicht verständlich","easyToUnderstand","thumb-up"],["Mein Problem wurde gelöst","solvedMyProblem","thumb-up"],["Sonstiges","otherUp","thumb-up"]],[["Benötigte Informationen nicht gefunden","missingTheInformationINeed","thumb-down"],["Zu umständlich/zu viele Schritte","tooComplicatedTooManySteps","thumb-down"],["Nicht mehr aktuell","outOfDate","thumb-down"],["Problem mit der Übersetzung","translationIssue","thumb-down"],["Problem mit Beispielen/Code","samplesCodeIssue","thumb-down"],["Sonstiges","otherDown","thumb-down"]],["Zuletzt aktualisiert: 2025-09-05 (UTC)."],[[["\u003cp\u003eJSON Web Tokens (JWTs) are required for API calls to Fleet Engine from low-trust environments like smartphones and browsers, providing authentication and authorization.\u003c/p\u003e\n"],["\u003cp\u003eJWTs are digitally signed by a service account on your server, a trusted environment, and passed to the client for secure communication with Fleet Engine.\u003c/p\u003e\n"],["\u003cp\u003eJWTs contain header and claim sections with information about the private key, encryption algorithm, token lifespan, and authorized access scopes like vehicle or trip IDs.\u003c/p\u003e\n"],["\u003cp\u003eFleet Engine utilizes private claims within JWTs to ensure data security and limit access to specific resources based on assigned roles and vehicle or task IDs.\u003c/p\u003e\n"],["\u003cp\u003eUnlike API keys, JWTs are short-lived and restrict operations to those permitted by the associated service account role, enhancing security.\u003c/p\u003e\n"]]],[],null,["# JSON Web Tokens\n\nA JSON Web Token (JWT) is an open web standard that's used for authenticating\nand authorizing information exchanges between a client and a server. When an app\nuser first signs in with the appropriate role credentials, the server creates\nand returns an encoded, digitally-signed JWT for use with subsequent requests.\nThis process both authenticates the user and authorizes them to access routes,\nservices, and resources based on their account role.\n\nFleet Engine requires the use of **JSON Web Tokens** (JWTs) for API method calls\nfrom **low-trust environments**: smartphones and browsers.\n\nA JWT originates on your server, is signed, encrypted, and passed to the client\nfor subsequent server interactions until it expires or is no longer valid.\n\n**Key details**\n\n- Use [Application Default Credentials](https://google.aip.dev/auth/4110) to authenticate and authorize against Fleet Engine.\n- Use an appropriate service account to sign JWTs. See [Fleet Engine serviceaccount](/maps/documentation/mobility/fleet-engine/essentials/set-up-fleet/service-accounts#fleet_engine_service_account_roles) roles in **Fleet Engine Basics**.\n\nUnlike API keys, JWTs are short lived and limit operations to only those that\nthe role is authorized to perform. For more information on JWTs, see\n[JSON Web Tokens](https://en.wikipedia.org/wiki/JSON_Web_Token) on Wikipedia. For detail on access roles, see\n[Service account roles](/maps/documentation/mobility/fleet-engine/essentials/set-up-fleet/service-accounts) in this guide.\n\nJWT elements\n------------\n\nJWTs contain a header and a claim section. The header section contains\ninformation such as the private key obtained from service accounts, and the\nencryption algorithm. The claim section contains information such as the JWT's\ncreate time, time to live, the services that the JWT claims\naccess to, and other authorization information to scope access; for\nexample, the delivery vehicle ID.\n\nThe following table provides descriptive details about JWT fields in general,\nas well as specific information about where you can find the values for these\nfields in your Fleet Engine Cloud project.\n\n| **Field** | **Description** |\n|-----------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| alg | The algorithm to use. \\`RS256\\`. |\n| typ | The type of token. \\`JWT\\`. |\n| kid | Your service account's private key ID. You can find this value in the `private_key_id` field of your service account JSON file. Make sure to use a key from a service account with the correct level of permissions. |\n[JWT header fields]\n\n| **Field** | **Description** |\n|---------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| iss | Your service account's email address, found in the `client_email` field of your service account JSON file. |\n| sub | Your service account's email address, found in the `client_email` field of your service account JSON file. |\n| aud | Your service account's `SERVICE_NAME`, in this case `https://fleetengine.googleapis.com/` |\n| iat | The timestamp when the JWT was created, specified in seconds elapsed since 00:00:00 `UTC, January 1, 1970`. Allow 10 minutes for skew. If the timestamp is too far in the past, or in the future, the server might report an error. |\n| exp | The timestamp when the JWT expires, specified in seconds elapsed since `00:00:00 UTC, January 1, 1970`. The request fails if the timestamp is more than one hour in the future. |\n| authorization | Depending on the use case, may contain `deliveryvehicleid`, `trackingid`, `taskid`, or `taskids`. If specifying taskids, the authorization scope must be an array in one of the following forms: `\"taskids\": [\"task_id_one\",\"task_id_two\"]` or `\"taskids\": [\"*\"]` |\n[JWT claims fields]\n\n### Fleet Engine JWT claims\n\nFleet Engine uses private claims. Using private claims ensures that only\nauthorized clients can access their own data.\n\nFor example, when your server issues a JSON Web Token for a driver's mobile\ndevice, it should contain either the `vehicleid` claim or the\n`deliveryvehicleid` claim with the value of that driver's vehicle ID. Then,\ndepending on the driver role, JWTs enable access only for the specific vehicle\nID and not any other arbitrary vehicle ID.\n\nFleet Engine uses the following private claims: \n\n### On-demand trips\n\n- **`vehicleid`** :\n - The Driver SDK always uses this claim, whether operating on a trip or vehicle. The Fleet Engine backend assures that the vehicle is associated with the requested trip before doing the modification.\n - The JWT can cover both vehicle and trip operations, even if not required, which may simplify the JWT signing implementation.\n- **`tripid`** :\n - The Consumer SDK always uses this claim.\n - The JWT can cover both vehicle and trip operations, even if not required, which may simplify the token signing implementation.\n\n### Scheduled tasks\n\n- `deliveryvehicleid`\n\n Use when calling per-delivery-vehicle\n APIs.\n- `taskid`\n\n Use when calling per-task APIs.\n- `taskids`\n\n Use when calling\n `BatchCreateTasksAPI`. This claim must be in array form,\n and the array should contain all task IDs necessary to complete the\n request. Don't include `delivervehicleid`,\n `trackingid`, or `taskid` claims.\n- `trackingid`\n\n Use when calling the\n `GetTaskTrackingInfoAPI`. The claim must match the tracking\n ID in the request. Don't include `delivervehicleid`,\n `taskid`, or `taskids` claims.\n\nWhat's next\n-----------\n\n- Read about [Fleet Engine security design](/maps/documentation/mobility/fleet-engine/essentials/set-up-fleet/security-design) to understand the complete authentication flow.\n- Learn how to [Issue JSON Web Tokens](/maps/documentation/mobility/fleet-engine/essentials/set-up-fleet/issue-jwt) from your server."]]
