google cloud java
v1.48.0
Client idiomatique Java pour les services Google Cloud Platform.
Des bibliothèques sont disponibles sur GitHub et Maven Central pour développer des applications Java qui interagissent avec des services Google Cloud individuels :
| Client | Niveau de version | Version |
|---|---|---|
| Bloc-notes AI Platform | ||
| Passerelle API | ||
| API Clés API | ||
| Approbation d'accès | ||
| API de notifications consultatives | ||
| AlliageDB | ||
| Connecteurs AlloyDB | ||
| API du hub d'analyse | ||
| Apigee Connect | ||
| API d'administration d'App Engine | ||
| Registre des artefacts | ||
| Inventaire des actifs | ||
| Charges de travail garanties pour le gouvernement | ||
| ML automatique | ||
| API du service de sauvegarde et de reprise après sinistre | ||
| BigQuery | ||
| Connexion BigQuery | ||
| Service de transfert de données BigQuery | ||
| Réservation BigQuery | ||
| Stockage BigQuery | ||
| Grande table | ||
| Client Bigtable HBase | ||
| Facturation | ||
| Budgets de facturation | ||
| Autorisation binaire | ||
| Construire | ||
| Perspectives CCAI | ||
| Service d'autorité de certification | ||
| Services de chaîne | ||
| Compositeur | ||
| Moteur de calcul | ||
| API de passerelle de connexion | ||
| Analyse des conteneurs | ||
| API des partenaires de contrôle | ||
| DNS | ||
| Catalogue de données | ||
| Fusion de données | ||
| Lignée des données | ||
| Prévention de la perte de données | ||
| Service de migration de bases de données | ||
| Dataplex | ||
| Dataproc | ||
| Métastore Dataproc | ||
| Banque de données | ||
| Flux de données | ||
| Débogueur | ||
| Déployer | ||
| API de flux de dialogue | ||
| API du moteur de découverte | ||
| Bord distribué | ||
| API de réseau Edge distribué | ||
| Documenter l'IA | ||
| Domaines | ||
| API de contacts essentiels | ||
| Arc Événementiel | ||
| API de magasin de fichiers | ||
| Firestore | ||
| Routage de la flotte | ||
| Fonctions | ||
| API du hub GKE | ||
| JE SUIS | ||
| API d'administration IAM | ||
| API de résolution des problèmes de stratégie IAM | ||
| API d'informations d'identification du compte de service IAM | ||
| Gestionnaire de contexte d'accès aux identités | ||
| API de proxy sensible à l'identité | ||
| API du gestionnaire d'infrastructure | ||
| Noyau de l'Internet des objets (IoT) | ||
| Système de détection d'intrusion | ||
| Service de gestion des clés | ||
| Moteur Kubernetes | ||
| Enregistrement | ||
| Service géré pour Microsoft Active Directory | ||
| Cache mémoire | ||
| Tableaux de bord de surveillance | ||
| Langue naturelle | ||
| Centre de connectivité réseau | ||
| API de gestion de réseau | ||
| API de sécurité réseau | ||
| API de configuration du système d'exploitation | ||
| Connexion au système d'exploitation | ||
| Politique de l'organisation | ||
| Profileur | ||
| Pub/Sous | ||
| Connecteur Kafka de pub/sous-groupe | ||
| Pub/Sub léger | ||
| Cale Kafka Pub/Sub Lite | ||
| Connecteur Spark Pub/Sub Lite | ||
| API d'autorité de certification publique | ||
| API de quotas | ||
| Recommandeur | ||
| Rédis | ||
| API du gestionnaire de ressources | ||
| API des paramètres de ressources | ||
| Vente au détail | ||
| API d'itinéraires | ||
| Planificateur | ||
| Gestion secrète | ||
| API du gestionnaire de sources sécurisées | ||
| API de gestion du centre de sécurité | ||
| Centre de commandement de sécurité | ||
| API de posture de sécurité | ||
| Scanner de sécurité | ||
| Accès au VPC sans serveur | ||
| API de contrôle des services | ||
| Répertoire des services | ||
| API de gestion des services | ||
| Utilisation des services | ||
| Coquille | ||
| Clé | ||
| Clé JDBC | ||
| Discours | ||
| Surveillance des pilotes Stackdriver | ||
| Trace Stackdriver | ||
| Stockage | ||
| Service de transfert de stockage | ||
| TPU | ||
| Solution de talents | ||
| Tâches | ||
| API d'automatisation des télécommunications | ||
| Synthèse vocale | ||
| Traduction | ||
| Migration de machines virtuelles | ||
| Sommet AI | ||
| API VertexAI | ||
| Intelligence vidéo | ||
| API d'assemblage vidéo | ||
| Transcodeur vidéo | ||
| Vision | ||
| Risque Web | ||
| Exécutions de flux de travail | ||
| Flux de travail | ||
| API des modules complémentaires Workspace | ||
| Postes de travail | ||
| reCAPTCHA Entreprise | ||
| API du hub API | ||
| API Ad Manager | ||
| API de validation d'adresse | ||
| Administrateur d'analyses | ||
| Données analytiques | ||
| Centre d'analyse | ||
| Anthos Multicloud | ||
| Service géré pour l'API Apache Kafka | ||
| API du Hub d'applications | ||
| Tableaux de la zone 120 | ||
| Sauvegarde pour GKE | ||
| Solution sans système d'exploitation | ||
| Lot | ||
| Connexions d'applications BeyondCorp | ||
| Connecteurs d'application BeyondCorp | ||
| Passerelles d'application BeyondCorp | ||
| Services de connecteur client BeyondCorp | ||
| Passerelles client BeyondCorp | ||
| GrandLac | ||
| API BigQuery DataPolicy | ||
| Migration BigQuery | ||
| API CSS | ||
| Gestionnaire de certificats | ||
| API de discussion | ||
| Commerce Consommateur Approvisionnement | ||
| API informatique confidentielle | ||
| API de passerelle de connexion | ||
| Étiquetage des données | ||
| Flux de données | ||
| Formulaire de données | ||
| API de connexion des développeurs | ||
| Dialogflow CX | ||
| Entrepôt de documents IA | ||
| Graphique des connaissances d'entreprise | ||
| Rapport d'erreur | ||
| Publication d'Eventarc | ||
| API de gestion du matériel GDC | ||
| API d'inventaire KMS | ||
| Sciences de la vie | ||
| API de diffusion en direct | ||
| Appender de journalisation | ||
| Initialiseur de servlet de journalisation | ||
| API des ensembles de données Maps Platform | ||
| API d'administration de la plateforme marketing | ||
| API de traduction multimédia | ||
| Rencontrer l'API | ||
| API Memorystore pour Redis | ||
| API marchand | ||
| API marchand | ||
| API marchand | ||
| API marchand | ||
| API marchand | ||
| API marchand | ||
| API de conversions marchandes | ||
| API LFP marchand | ||
| API de notifications aux marchands | ||
| API de quotas marchands | ||
| API du Centre de migration | ||
| Surveillance des étendues des métriques | ||
| Fournisseur de système de fichiers NIO pour le stockage | ||
| API NetApp | ||
| API des services réseau | ||
| Base de données Oracle@API | ||
| API Parallelstore | ||
| Protection contre le phishing | ||
| API Places (nouveau) | ||
| API Places Insights | ||
| API du simulateur de politiques | ||
| Catalogue privé | ||
| API du gestionnaire d'accès privilégié | ||
| Connecteur Flink Pub/Sub Lite | ||
| API d'évaluation rapide de la migration | ||
| Recommandations IA | ||
| API de registre | ||
| API d'optimisation d'itinéraire | ||
| Courir | ||
| API des paramètres du centre de commande de sécurité | ||
| API d'intégrité du service | ||
| API solaire | ||
| API d'informations sur le stockage | ||
| API de prise en charge | ||
| Moteur VMware | ||
| API Vision IA | ||
| API d'événements d'espace de travail |
Si le service n'est pas répertorié, google-api-java-client s'interface avec des API Google Cloud supplémentaires à l'aide d'une ancienne interface REST.
Lors de la création d'applications Java, la préférence doit être donnée aux bibliothèques répertoriées dans le tableau.
La plupart des bibliothèques google-cloud nécessitent un ID de projet. Il existe plusieurs façons de spécifier cet ID de projet.
google-cloud à partir de Compute/App Engine, il n'est pas nécessaire de spécifier un ID de projet. Il est automatiquement déduit de l'environnement de production.google-cloud ailleurs, vous pouvez effectuer l'une des opérations suivantes :Fournissez l’ID du projet lors de la création des options de service. Par exemple, pour utiliser Datastore à partir d'un projet avec l'ID "PROJECT_ID", vous pouvez écrire :
Datastore datastore = DatastoreOptions . newBuilder (). setProjectId ( "PROJECT_ID" ). build (). getService (); Spécifiez la variable d'environnement GOOGLE_CLOUD_PROJECT comme ID de projet souhaité.
Définissez l'ID du projet à l'aide du SDK Google Cloud. Pour utiliser le SDK, téléchargez le SDK si vous ne l'avez pas déjà fait et définissez l'ID du projet à partir de la ligne de commande. Par exemple:
gcloud config set project PROJECT_ID
google-cloud détermine l'ID du projet à partir des sources suivantes dans l'ordre indiqué, en s'arrêtant une fois qu'il a trouvé une valeur :
GOOGLE_CLOUD_PROJECTGOOGLE_APPLICATION_CREDENTIALSDans les cas où la bibliothèque peut s'attendre explicitement à un ID de projet, nous fournissons un assistant qui peut fournir l'ID de projet déduit :
import com . google . cloud . ServiceOptions ;
...
String projectId = ServiceOptions . getDefaultProjectId (); google-cloud-java utilise https://github.com/googleapis/google-auth-library-java pour authentifier les demandes. google-auth-library-java prend en charge un large éventail de types d'authentification ; voir le README et le javadoc du projet pour plus de détails.
Lorsque vous utilisez des bibliothèques Google Cloud à partir d'un environnement Google Cloud Platform tel que Compute Engine, Kubernetes Engine ou App Engine, aucune étape d'authentification supplémentaire n'est nécessaire.
Par exemple:
Storage storage = StorageOptions . getDefaultInstance (). getService ();ou:
CloudTasksClient cloudTasksClient = CloudTasksClient . create ();Générez une clé de compte de service JSON.
Après avoir téléchargé cette clé, vous devez effectuer l'une des opérations suivantes :
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/my/key.json Storage storage = StorageOptions . newBuilder ()
. setCredentials ( ServiceAccountCredentials . fromStream ( new FileInputStream ( "/path/to/my/key.json" )))
. build ()
. getService (); Si vous l'exécutez localement à des fins de développement/de test, vous pouvez utiliser le SDK Google Cloud. Créez les informations d'identification par défaut de l'application avec gcloud auth application-default login , puis google-cloud détectera automatiquement ces informations d'identification.
Si vous disposez déjà d'un jeton d'accès OAuth2, vous pouvez l'utiliser pour vous authentifier (notez que dans ce cas, le jeton d'accès ne sera pas automatiquement actualisé) :
Credentials credentials = GoogleCredentials . create ( new AccessToken ( accessToken , expirationTime ));
Storage storage = StorageOptions . newBuilder ()
. setCredentials ( credentials )
. build ()
. getService ();ou:
Credentials credentials = GoogleCredentials . create ( new AccessToken ( accessToken , expirationTime ));
CloudTasksSettings cloudTasksSettings = CloudTasksSettings . newBuilder ()
. setCredentialProvider ( FixedCredentialsProvider . create ( credentials ))
. build ();
CloudTasksClient cloudTasksClient = CloudTasksClient . create ( cloudTasksSettings ); Si aucune information d'identification n'est fournie, google-cloud tentera de les détecter à partir de l'environnement à l'aide de GoogleCredentials.getApplicationDefault() qui recherchera les informations d'identification par défaut de l'application aux emplacements suivants (dans l'ordre) :
GOOGLE_APPLICATION_CREDENTIALSgcloud auth application-default login du SDK Google CloudL'authentification avec les clés API est prise en charge par une poignée d'API Google Cloud.
Nous étudions activement les moyens d'améliorer l'expérience des clés API. Actuellement, pour utiliser une clé API avec une bibliothèque client Java, vous devez définir manuellement l'en-tête du client de service concerné.
Par exemple, pour définir la clé API avec le service Language :
public LanguageServiceClient createGrpcClientWithApiKey ( String apiKey ) throws Exception {
// Manually set the api key via the header
Map < String , String > header = new HashMap < String , String >() { { put ( "x-goog-api-key" , apiKey );}};
FixedHeaderProvider headerProvider = FixedHeaderProvider . create ( header );
// Create the client
TransportChannelProvider transportChannelProvider = InstantiatingGrpcChannelProvider . newBuilder (). setHeaderProvider ( headerProvider ). build ();
LanguageServiceSettings settings = LanguageServiceSettings . newBuilder (). setTransportChannelProvider ( transportChannelProvider ). build ();
LanguageServiceClient client = LanguageServiceClient . create ( settings );
return client ;
}Un exemple d'instanciation avec Language Client utilisant rest :
public LanguageServiceClient createRestClientWithApiKey ( String apiKey ) throws Exception {
// Manually set the api key header
Map < String , String > header = new HashMap < String , String >() { { put ( "x-goog-api-key" , apiKey );}};
FixedHeaderProvider headerProvider = FixedHeaderProvider . create ( header );
// Create the client
TransportChannelProvider transportChannelProvider = InstantiatingHttpJsonChannelProvider . newBuilder (). setHeaderProvider ( headerProvider ). build ();
LanguageServiceSettings settings = LanguageServiceSettings . newBuilder (). setTransportChannelProvider ( transportChannelProvider ). build ();
LanguageServiceClient client = LanguageServiceClient . create ( settings );
return client ;
}Pour obtenir de l'aide, suivez les instructions du document de dépannage.
Les bibliothèques clientes Google Cloud utilisent HTTPS et gRPC dans la communication sous-jacente avec les services. Dans les deux protocoles, vous pouvez configurer un proxy à l'aide des propriétés https.proxyHost et (facultatif) https.proxyPort .
Pour un proxy plus personnalisé avec gRPC, vous devrez fournir un ProxyDetector au ManagedChannelBuilder :
import com . google . api . core . ApiFunction ;
import com . google . api . gax . rpc . TransportChannelProvider ;
import com . google . cloud . tasks . v2 . CloudTasksClient ;
import com . google . cloud . tasks . v2 . CloudTasksSettings ;
import com . google . cloud . tasks . v2 . stub . CloudTasksStubSettings ;
import io . grpc . HttpConnectProxiedSocketAddress ;
import io . grpc . ManagedChannelBuilder ;
import io . grpc . ProxiedSocketAddress ;
import io . grpc . ProxyDetector ;
import javax . annotation . Nullable ;
import java . io . IOException ;
import java . net . InetSocketAddress ;
import java . net . SocketAddress ;
public CloudTasksClient getService () throws IOException {
TransportChannelProvider transportChannelProvider =
CloudTasksStubSettings . defaultGrpcTransportProviderBuilder ()
. setChannelConfigurator (
new ApiFunction < ManagedChannelBuilder , ManagedChannelBuilder >() {
@ Override
public ManagedChannelBuilder apply ( ManagedChannelBuilder managedChannelBuilder ) {
return managedChannelBuilder . proxyDetector (
new ProxyDetector () {
@ Nullable
@ Override
public ProxiedSocketAddress proxyFor ( SocketAddress socketAddress )
throws IOException {
return HttpConnectProxiedSocketAddress . newBuilder ()
. setUsername ( PROXY_USERNAME )
. setPassword ( PROXY_PASSWORD )
. setProxyAddress ( new InetSocketAddress ( PROXY_HOST , PROXY_PORT ))
. setTargetAddress (( InetSocketAddress ) socketAddress )
. build ();
}
});
}
})
. build ();
CloudTasksSettings cloudTasksSettings =
CloudTasksSettings . newBuilder ()
. setTransportChannelProvider ( transportChannelProvider )
. build ();
return CloudTasksClient . create ( cloudTasksSettings );
} Les opérations de longue durée (LRO) sont souvent utilisées pour les appels d'API dont l'exécution est censée prendre beaucoup de temps (par exemple, le provisionnement d'une instance GCE ou d'un pipeline Dataflow). L'appel API initial crée une « opération » sur le serveur et renvoie un ID d'opération pour suivre sa progression. Les RPC LRO ont le suffixe Async ajouté au nom de l'appel (c'est-à-dire clusterControllerClient.createClusterAsync() )
Nos clients générés fournissent une interface agréable pour démarrer l’opération puis attendre la fin de l’opération. Ceci est accompli en renvoyant un OperationFuture . Lors de l'appel de get() sur OperationFuture , la bibliothèque cliente interrogera l'opération pour vérifier l'état de l'opération.
Par exemple, prenons un exemple d'opération createCluster dans google-cloud-dataproc v4.20.0 :
try ( ClusterControllerClient clusterControllerClient = ClusterControllerClient . create ()) {
CreateClusterRequest request =
CreateClusterRequest . newBuilder ()
. setProjectId ( "{PROJECT_ID}" )
. setRegion ( "{REGION}" )
. setCluster ( Cluster . newBuilder (). build ())
. setRequestId ( "{REQUEST_ID}" )
. setActionOnFailedPrimaryWorkers ( FailureAction . forNumber ( 0 ))
. build ();
OperationFuture < Cluster , ClusterOperationMetadata > future =
clusterControllerClient . createClusterOperationCallable (). futureCall ( request );
// Do something.
Cluster response = future . get ();
} catch ( CancellationException e ) {
// Exceeded the default RPC timeout without the Operation completing.
// Library is no longer polling for the Operation status. Consider
// increasing the timeout.
} Les opérations d'interrogation ont un délai d'expiration par défaut qui varie d'un service à l'autre. La bibliothèque lancera une java.util.concurrent.CancellationException avec le message : Task was cancelled. si le délai d'attente dépasse l'opération. Une CancellationException ne signifie pas que l'opération GCP backend a été annulée. Cette exception est levée depuis la bibliothèque cliente lorsqu'elle a dépassé le délai d'attente total sans recevoir de statut de réussite de l'opération. Nos bibliothèques clientes respectent les valeurs configurées définies dans OperationTimedPollAlgorithm pour chaque RPC.
Remarque : La bibliothèque cliente gère le mécanisme d'interrogation de l'opération pour vous. Par défaut, il n'est pas nécessaire d'interroger manuellement le statut vous-même.
Chaque LRO RPC possède un ensemble de valeurs par défaut préconfigurées. Vous pouvez trouver ces valeurs en recherchant dans la classe StubSettings de chaque Client. Les paramètres LRO par défaut sont initialisés dans la méthode initDefaults() dans la classe Builder imbriquée.
Par exemple, dans google-cloud-aiplatform v3.24.0, l'OperationTimedPollAlgorithm par défaut a ces valeurs par défaut :
OperationTimedPollAlgorithm . create (
RetrySettings . newBuilder ()
. setInitialRetryDelay ( Duration . ofMillis ( 5000L ))
. setRetryDelayMultiplier ( 1.5 )
. setMaxRetryDelay ( Duration . ofMillis ( 45000L ))
. setInitialRpcTimeout ( Duration . ZERO )
. setRpcTimeoutMultiplier ( 1.0 )
. setMaxRpcTimeout ( Duration . ZERO )
. setTotalTimeout ( Duration . ofMillis ( 300000L ))
. build ())Les tentatives et les LRO partagent la même classe RetrySettings. Notez le lien correspondant :
Les valeurs RPC Timeout n'ont aucune utilité dans les LRO et peuvent être omises ou définies sur les valeurs par défaut ( Duration.ZERO pour les délais d'attente ou 1.0 pour le multiplicateur).
Pour configurer les valeurs LRO, créez un objet OperationTimedPollAlgorithm et mettez à jour l'algorithme d'interrogation du RPC. Par exemple:
ClusterControllerSettings . Builder settingsBuilder = ClusterControllerSettings . newBuilder ();
TimedRetryAlgorithm timedRetryAlgorithm = OperationTimedPollAlgorithm . create (
RetrySettings . newBuilder ()
. setInitialRetryDelay ( Duration . ofMillis ( 500L ))
. setRetryDelayMultiplier ( 1.5 )
. setMaxRetryDelay ( Duration . ofMillis ( 5000L ))
. setInitialRpcTimeout ( Duration . ZERO ) // ignored
. setRpcTimeoutMultiplier ( 1.0 ) // ignored
. setMaxRpcTimeout ( Duration . ZERO ) // ignored
. setTotalTimeout ( Duration . ofHours ( 24L )) // set polling timeout to 24 hours
. build ());
settingsBuilder . createClusterOperationSettings ()
. setPollingAlgorithm ( timedRetryAlgorithm );
ClusterControllerClient clusterControllerClient = ClusterControllerClient . create ( settingsBuilder . build ()); Remarque : La configuration ci-dessus modifie uniquement les valeurs LRO pour le RPC createClusterOperation . Les autres RPC du client utiliseront toujours les valeurs LRO préconfigurées de chaque RPC.
Si vous utilisez plusieurs bibliothèques clientes Google Cloud, nous vous recommandons d'utiliser l'un de nos artefacts de nomenclature (BOM) pour vous aider à gérer les versions de dépendances. Pour plus d'informations, consultez Utilisation des bibliothèques clientes Cloud.
Java 8 ou supérieur est requis pour utiliser les clients de ce référentiel.
Les clients de ce référentiel utilisent HTTP ou gRPC pour la couche de transport. Tous les clients HTTP doivent fonctionner dans tous les environnements.
Pour les clients qui utilisent gRPC, les plates-formes prises en charge sont limitées par les plates-formes prises en charge par Forked Tomcat Native, ce qui signifie pour les architectures uniquement x86_64, et pour les systèmes d'exploitation, Mac OS X, Windows et Linux. De plus, gRPC limite l'utilisation de plates-formes avec des restrictions de thread.
Ainsi, les éléments suivants ne sont pas pris en charge :
Les environnements suivants devraient fonctionner (entre autres) :
Cette bibliothèque fournit des outils pour vous aider à écrire des tests pour le code qui utilise les services Google-Cloud.
Voir TESTS pour en savoir plus sur l'utilisation de nos assistants de test.
Cette bibliothèque suit le versionnage sémantique, avec quelques qualifications supplémentaires :
Les composants marqués avec @BetaApi ou @Experimental sont considérés comme des fonctionnalités « 0.x » dans une bibliothèque « 1.x ». Cela signifie qu'ils peuvent passer d'une version mineure à une version corrective de manière incompatible. Ces fonctionnalités ne doivent être utilisées par aucune bibliothèque « B » qui a elle-même des consommateurs, à moins que les composants de la bibliothèque B qui utilisent les fonctionnalités @BetaApi ne soient également marqués par @BetaApi . Les fonctionnalités marquées comme @BetaApi sont sur le point de devenir à terme des fonctionnalités "1.x" avec le marqueur supprimé.
Exception spéciale pour google-cloud-java : google-cloud-java est autorisé à dépendre des fonctionnalités @BetaApi dans gax-java sans déclarer le code consommateur @BetaApi , car gax-java et google-cloud-java évoluent au rythme l'un de l'autre . Pour cette raison, gax-java ne doit pas être utilisé indépendamment de google-cloud-java.
Les composants marqués avec @InternalApi sont techniquement publics, mais uniquement en raison des limitations des modificateurs d'accès de Java. Aux fins du semver, ils doivent être considérés comme privés.
Les interfaces marquées avec @InternalExtensionOnly sont publiques, mais ne doivent être implémentées que par des classes internes. Pour les besoins de Semver, nous nous réservons le droit d'ajouter à ces interfaces sans implémentations par défaut (pour Java 7).
Veuillez noter que ces clients sont actuellement en développement actif. Toute version version 0.xy est sujette à tout moment à des modifications rétrocompatibles.
Les bibliothèques définies à un niveau de qualité stable doivent être stables et toutes les mises à jour des bibliothèques sont garanties comme étant rétrocompatibles. Toute modification rétrocompatible entraînera l’incrément de version majeur (1.xy -> 2.0.0).
Les bibliothèques définies au niveau de qualité Aperçu sont toujours en cours de développement et sont plus susceptibles de recevoir des mises à jour incompatibles avec les versions antérieures. De plus, il est possible que les bibliothèques Preview soient obsolètes et supprimées avant d'être promues au format Preview ou Stable.
Si vous utilisez IntelliJ ou Eclipse, vous pouvez ajouter des bibliothèques clientes à votre projet à l'aide de ces plugins IDE :
Outre l'ajout de bibliothèques clientes, les plugins fournissent des fonctionnalités supplémentaires, telles que la gestion des clés de compte de service. Reportez-vous à la documentation de chaque plugin pour plus de détails.
Ces bibliothèques clientes peuvent être utilisées sur App Engine standard pour l'environnement d'exécution Java 8 et App Engine flexible (y compris le runtime Compat). La plupart des bibliothèques ne fonctionnent pas sur le standard App Engine pour l'environnement d'exécution Java 7. Cependant, Datastore, Storage et Bigquery devraient fonctionner.
Les contributions à cette bibliothèque sont toujours les bienvenues et fortement encouragées.
Consultez la documentation CONTRIBUTING de google-cloud et la documentation partagée pour plus d'informations sur la façon de démarrer.
Veuillez noter que ce projet est publié avec un code de conduite des contributeurs. En participant à ce projet, vous acceptez d'en respecter les termes. Voir le Code de conduite pour plus d'informations.
Apache 2.0 - Voir LICENCE pour plus d'informations.
