We recommend using our language-specific GAPI client libraries for a better experience than developing over raw REST or gRPC for server to server communication.
If libraries do not exist in your application's language, we recommend using gRPC or the Fleet Engine REST endpoints.
In order to authenticate with Fleet Engine, you must have a signed JSON web token. See Authentication and Authorization for details.
Java
Java libraries are published under google.maps.fleetengine.delivery.v1
.
Gradle
plugins {
id "maven-publish"
id "com.google.cloud.artifactregistry.gradle-plugin" version "2.1.4"
}
publishing {
repositories {
maven {
url "artifactregistry://us-maven.pkg.dev/fleetengine-gapic/maven"
}
}
}
repositories {
maven {
url "artifactregistry://us-maven.pkg.dev/fleetengine-gapic/maven"
}
}
dependencies {
implementation 'com.google.maps:gapic-google-maps-fleetengine-delivery-v1-java:latest.release'
}
Maven
<project>
<distributionManagement>
<snapshotRepository>
<id>artifact-registry</id>
<url>artifactregistry://us-maven.pkg.dev/fleetengine-gapic/maven</url>
</snapshotRepository>
<repository>
<id>artifact-registry</id>
<url>artifactregistry://us-maven.pkg.dev/fleetengine-gapic/maven</url>
</repository>
</distributionManagement>
<repositories>
<repository>
<id>artifact-registry</id>
<url>artifactregistry://us-maven.pkg.dev/fleetengine-gapic/maven</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<build>
<extensions>
<extension>
<groupId>com.google.cloud.artifactregistry</groupId>
<artifactId>artifactregistry-maven-wagon</artifactId>
<version>2.1.4</version>
</extension>
</extensions>
</build>
<dependency>
<groupId>com.google.maps</groupId>
<artifactId>gapic-google-maps-fleetengine-delivery-v1-java</artifactId>
<version>LATEST</version>
</dependency>
</project>
You can utilize the Fleet Engine Auth Library for Java to create signed JSON web tokens within the Java environment.
You can view Java examples for interacting with the Fleet Engine API on the Getting started with Fleet Engine page.
Node.js / TypeScript
npm
You may specify the library URL in the dependencies
section of
package.json
:
{
"dependencies": {
"@googlemaps/fleetengine-delivery": "https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/maps-fleetengine-delivery-v1-nodejs.tar.gz",
"googleapis": "^118.0.0"
}
}
Sample code:
const {google} = require("googleapis");
const iamcredentials = google.iamcredentials("v1");
const fleetengine = require("@googlemaps/fleetengine-delivery");
// CONSTANTS
const PROJECT_ID = "YOUR_GCP_PROJECT_NAME";
const VEHICLE_ID = "YOUR_VEHICLE_ID";
const SERVICE_ACCOUNT = "YOUR_SERVICE_ACCOUNT";
const SERVICE_ACCOUNT_EMAIL = `${SERVICE_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com`;
// CREATE A JWT FOR AUTHENTICATION
const HOWLONG = 55 * 60; // 55 minutes, cannot be more than 60 minutes
async function signToken(claims) {
const googleAuth = new google.auth.GoogleAuth({
scopes: ["https://www.googleapis.com/auth/cloud-platform"],
});
const authClient = await googleAuth.getClient();
google.options({auth: authClient});
const now = Math.round(Date.now() / 1000);
const iat = now - 300;
const exp = now + HOWLONG;
const request = {
name: `projects/-/serviceAccounts/${SERVICE_ACCOUNT_EMAIL}`,
requestBody: {
payload: JSON.stringify({
iss: SERVICE_ACCOUNT_EMAIL,
sub: SERVICE_ACCOUNT_EMAIL,
aud: "https://fleetengine.googleapis.com/",
iat: iat,
exp: exp,
authorization: claims
}),
}
};
const response = await await iamcredentials.projects.serviceAccounts
.signJwt(request)
.catch((err) => {
if (err.errors) throw err.errors;
else throw err;
});
return response.data.signedJwt;
}
// MAKE A REQUEST
async function main() {
const claims = {
deliveryvehicleid: VEHICLE_ID
};
signToken(claims).then(token => {
let auth = new GoogleAuth();
auth.cachedCredential = new AuthorizationHeaderProvider();
const client = new fleetengine.DeliveryServiceClient({ auth: auth });
client.getDeliveryVehicle({parent: `providers/${PROJECT_ID}`}).then(function(resp) {
console.log(resp);
}, function(err) {
console.log(err);
});
});
}
class AuthorizationHeaderProvider {
getRequestMetadata(url, callback) {
callback(null, {'authorization': `Bearer ${token}`});
}
}
main().catch(console.error);
Go
The Go library is packaged as a module at https://pkg.go.dev/google.golang.org/genproto/googleapis/maps/fleetengine/delivery/v1
package main
import (
"context"
"fmt"
"os"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/metadata"
credentials "cloud.google.com/go/iam/credentials/apiv1"
credentialspb "cloud.google.com/go/iam/credentials/apiv1/credentialspb"
delivery "google.golang.org/genproto/googleapis/maps/fleetengine/delivery/v1"
)
func (a *auth) signToken(ctx context.Context, email string, iat time.Time, exp time.Time, aud string, scope string, privateClaims map[string]any) (string, error) {
claimSet := struct {
Iss string `json:"iss"`
Sub string `json:"sub"`
Aud string `json:"aud"`
Scope string `json:"scope"`
Iat int64 `json:"iat"`
Exp int64 `json:"exp"`
Authorization any `json:"authorization"`
}{email, email, aud, scope, iat.Unix(), exp.Unix(), nil}
if privateClaims != nil {
if auth, ok := privateClaims["authorization"]; ok {
claimSet.Authorization = auth
}
}
client, err := credentials.NewIamCredentialsClient(ctx)
if err != nil {
return "", fmt.Errorf("Could not instantiate IAM credentials client: %v", err)
}
payloadJSON, err := json.Marshal(claimSet)
if err != nil {
return "", fmt.Errorf("Could not marshal JWT payload: %v", err)
}
req := &credentialspb.SignJwtRequest{
Name: fmt.Sprintf("projects/-/serviceAccounts/%s", email),
Payload: string(payloadJSON),
JwtType: "JWT",
}
resp, err := client.SignJwt(ctx, req)
if err != nil {
return "", fmt.Errorf("SignJwt request failed with error: %v", err)
}
return resp.SignedJwt, nil
}
func main() {
project_id := "YOUR_GCP_PROJECT_NAME"
vehicle_id := "YOUR_VEHICLE_ID"
service_account_name := "YOUR_SERVICE_ACCOUNT"
service_account_email := fmt.Sprintf("%s@%s.iam.gserviceaccount.com", service_account_name, project_id)
ctx := context.Background()
iat := time.Now().Add(-time.Minute * 5)
exp := time.Now().Add(time.Minute * 55)
aud := "https://fleetengine.googleapis.com/"
scope := "https://www.googleapis.com/auth/cloud-platform"
claims := map[string]string{
"deliveryvehicleid": vehicle_id,
}
token := signToken(ctx, service_account_email, iat, exp, aud, scope, claims)
opts := []grpc.DialOption{
grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, "")),
}
auth_header := string(fmt.Sprintf("Bearer %s", token))
address := "fleetengine.googleapis.com:443"
ctx = metadata.AppendToOutgoingContext(ctx, "authorization", auth_header)
conn, _ := grpc.DialContext(ctx, address, opts...)
request := &delivery.GetDeliveryVehicleRequest {
Name: fmt.Sprintf("providers/%s/deliveryVehicles/%s", project_id, vehicle_id),
}
svc := delivery.NewDeliveryServiceClient(conn)
response, err := svc.GetDeliveryVehicle(ctx, request)
if (err != nil) {
fmt.Println(err)
return
}
fmt.Println(response)
}
Python
pip
pip install google-auth
pip install https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/maps-fleetengine-delivery-v1-py.tar.gz
Sample code:
from maps.fleetengine import delivery_v1
import google.auth
from google.auth import jwt
from google.auth import iam
from google.auth.transport import requests
# CONSTANTS
PROJECT_ID = 'YOUR_GCP_PROJECT_NAME'
VEHICLE_ID = 'YOUR_VEHICLE_ID'
SERVICE_ACCOUNT = f'YOUR_SERVICE_ACCOUNT@{PROJECT_ID}.iam.gserviceaccount.com'
# CREATE A JWT FOR AUTHENTICATION
credentials, _ = google.auth.default(
scopes=['https://www.googleapis.com/auth/iam'])
signer = iam.Signer(requests.Request(), credentials, SERVICE_ACCOUNT)
jwt_credentials = jwt.Credentials(
signer,
issuer=SERVICE_ACCOUNT,
subject=SERVICE_ACCOUNT,
audience='https://fleetengine.googleapis.com/',
additional_claims={
"authorization": {
"vehicleid" : VEHICLE_ID
}
}
)
# MAKE A REQUEST
maps_fleetengine_client = fleetengine_v1.DeliveryServiceClient(credentials=jwt_credentials)
request = fleetengine_v1.GetDeliveryVehicleRequest(name=f'providers/{PROJECT_ID}/deliveryVehicles/{VEHICLE_ID}')
response = maps_fleetengine_client.get_delivery_vehicle(request=request)
C#
The C# library can be downloaded from https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/google-maps-fleetengine-delivery-v1-csharp.tar.gz
PHP
The PHP library can be downloaded from https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/google-maps-fleetengine-delivery-v1-php.tar.gz
Ruby
The Ruby library can be downloaded from https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/google-maps-fleetengine-delivery-v1-ruby.tar.gz