Bibliothèques clientes GAPI

Pour une meilleure expérience, nous vous recommandons d'utiliser nos bibliothèques clientes GAPI propres à chaque langage plutôt que de développer des applications à l'aide de REST ou gRPC brut pour la communication de serveur à serveur. Les fichiers tampons de protocole sur lesquels ces clients sont basés sont disponibles publiquement à l'adresse https://github.com/googleapis/googleapis/tree/master/google/maps/fleetengine/delivery/v1.

Si des bibliothèques n'existent pas dans le langage de votre application, nous vous recommandons d'utiliser gRPC ou les points de terminaison REST Fleet Engine.

Pour vous authentifier auprès de Fleet Engine, vous devez disposer d'un jeton Web JSON signé. Pour en savoir plus, consultez la page Authentification et autorisation.

Java

Les bibliothèques Java sont publiées sous 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>

Vous pouvez utiliser la bibliothèque d'authentification Fleet Engine pour Java afin de créer des jetons Web JSON signés dans l'environnement Java.

Vous pouvez consulter des exemples Java pour interagir avec l'API Fleet Engine sur la page Premiers pas avec Fleet Engine.

Node.js / TypeScript

npm

Vous pouvez spécifier l'URL de la bibliothèque dans la section dependencies du fichier package.json:

{
  "dependencies": {
    "@googlemaps/fleetengine-delivery": "https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/maps-fleetengine-delivery-v1-nodejs.tar.gz",
    "google-auth-library": "^9.2.0",
    "googleapis": "^118.0.0"
  }
}

Exemple de code :

const {google} = require('googleapis');
const fleetengine = require('@googlemaps/fleetengine-delivery');
const {GoogleAuth} = require('google-auth-library');

// 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 google.iamcredentials('v1').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(token);
      const client = new fleetengine.DeliveryServiceClient({ auth: auth });

      client.getDeliveryVehicle({name: `providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}`}).then(function(resp) {
        console.log(resp);
      }, function(err) {
        console.log(err);
      });
    });
}

class AuthorizationHeaderProvider {
    constructor(token) {
        this.token = token;
    }

    getRequestMetadata(url, callback) {
        callback(null, {'authorization': `Bearer ${this.token}`});
    }
}

main().catch(console.error);

Go

La bibliothèque Go est empaquetée sous forme de module à l'adresse https://pkg.go.dev/cloud.google.com/go/maps.

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 "cloud.google.com/go/maps/fleetengine/delivery/apiv1/deliverypb"
)

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

Consultez la page https://pypi.org/project/google-maps-fleetengine-delivery/0.1.0/

pip

pip install google-auth
pip install google-maps-fleetengine-delivery

Exemple de code :

from google.maps import fleetengine_delivery
import google.auth
from google.auth import jwt, 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_delivery.DeliveryServiceClient(credentials=jwt_credentials)
request = fleetengine_delivery.GetDeliveryVehicleRequest(name=f'providers/{PROJECT_ID}/deliveryVehicles/{VEHICLE_ID}')
response = maps_fleetengine_client.get_delivery_vehicle(request=request)

C#

Les instructions d'installation de la bibliothèque C# sont disponibles à l'adresse https://www.nuget.org/packages/Google.Maps.FleetEngine.Delivery.V1.

PHP

La bibliothèque PHP peut être téléchargée à l'adresse suivante : https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/google-maps-fleetengine-delivery-v1-php.tar.gz

Ruby

La bibliothèque Ruby peut être téléchargée à l'adresse https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/google-maps-fleetengine-delivery-v1-ruby.tar.gz.