Bibliotecas de cliente GAPI

Recomendamos usar nossas bibliotecas de cliente GAPI específicas da linguagem para ter uma experiência melhor do que desenvolver usando REST ou gRPC bruto para comunicação entre servidores. Os arquivos protobuf em que esses clientes se baseiam estão disponíveis publicamente em https://github.com/googleapis/googleapis/tree/master/google/maps/fleetengine/delivery/v1.

Se não houver bibliotecas na linguagem do seu aplicativo, recomendamos usar o gRPC ou os endpoints do Fleet Engine REST.

Para autenticar com o Fleet Engine, você precisa ter um token da Web JSON assinado. Consulte os detalhes em Autenticação e autorização.

Java

As bibliotecas Java são publicadas em 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>

Use a biblioteca de autenticação do Fleet Engine para Java para criar tokens da Web JSON assinados no ambiente Java.

Veja exemplos de Java para interagir com a API Fleet Engine na página Introdução ao Fleet Engine.

Node.js / TypeScript

npm

É possível especificar o URL da biblioteca na seção dependencies de 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"
  }
}

Exemplo de código:

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

A biblioteca Go é empacotada como um módulo em 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

Consulte https://pypi.org/project/google-maps-fleetengine-delivery/0.1.0/

pip

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

Exemplo de código:

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#

As instruções de instalação da biblioteca C# podem ser encontradas em https://www.nuget.org/packages/Google.Maps.FleetEngine.Delivery.V1.

PHP

Faça o download da biblioteca PHP em https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/google-maps-fleetengine-delivery-v1-php.tar.gz

Ruby

Faça o download da biblioteca do Ruby em https://storage.googleapis.com/fleetengine-gapic/dist/latest_release/google-maps-fleetengine-delivery-v1-ruby.tar.gz