google cloud java
v1.48.0
Cliente idiomático Java para servicios de Google Cloud Platform.
Las bibliotecas están disponibles en GitHub y Maven Central para desarrollar aplicaciones Java que interactúan con servicios individuales de Google Cloud:
| Cliente | Nivel de lanzamiento | Versión |
|---|---|---|
| Cuadernos de plataforma AI | ||
| Puerta de enlace API | ||
| API de claves API | ||
| Aprobación de acceso | ||
| API de notificaciones de asesoramiento | ||
| aleacióndb | ||
| Conectores AlloyDB | ||
| API del centro de análisis | ||
| Conexión Apigee | ||
| API de administración de App Engine | ||
| Registro de artefactos | ||
| Inventario de activos | ||
| Cargas de trabajo aseguradas para el gobierno | ||
| AA automático | ||
| API de servicio de respaldo y recuperación ante desastres | ||
| Gran consulta | ||
| Conexión de BigQuery | ||
| Servicio de transferencia de datos de BigQuery | ||
| Reserva de BigQuery | ||
| Almacenamiento de BigQuery | ||
| Mesa grande | ||
| Cliente Hbase de Bigtable | ||
| Facturación | ||
| Presupuestos de facturación | ||
| Autorización binaria | ||
| Construir | ||
| Perspectivas de la CCAI | ||
| Servicio de autoridad certificadora | ||
| Servicios de canal | ||
| Compositor | ||
| Motor de Computación | ||
| Conectar API de puerta de enlace | ||
| Análisis de contenedores | ||
| API de socios de controles | ||
| DNS | ||
| Catálogo de datos | ||
| Fusión de datos | ||
| Linaje de datos | ||
| Prevención de pérdida de datos | ||
| Servicio de migración de bases de datos | ||
| datosplex | ||
| procesamiento de datos | ||
| Metaalmacén de datos | ||
| almacén de datos | ||
| flujo de datos | ||
| Depurador | ||
| Desplegar | ||
| API de flujo de diálogo | ||
| API del motor de descubrimiento | ||
| Borde distribuido | ||
| API de red de borde distribuido | ||
| Documento AI | ||
| Dominios | ||
| API de contactos esenciales | ||
| Eventarc | ||
| API de almacén de archivos | ||
| Tienda de fuego | ||
| Enrutamiento de flotas | ||
| Funciones | ||
| API del centro de GKE | ||
| SOY | ||
| API de administración de IAM | ||
| API de solución de problemas de políticas de IAM | ||
| API de credenciales de cuenta de servicio de IAM | ||
| Administrador de contexto de acceso a identidad | ||
| API de proxy con reconocimiento de identidad | ||
| API del administrador de infraestructura | ||
| Núcleo de Internet de las cosas (IoT) | ||
| Sistema de detección de intrusiones | ||
| Servicio de gestión de claves | ||
| Motor Kubernetes | ||
| Explotación florestal | ||
| Servicio administrado para Microsoft Active Directory | ||
| Memcache | ||
| Paneles de monitoreo | ||
| Lenguaje Natural | ||
| Centro de conectividad de red | ||
| API de gestión de red | ||
| API de seguridad de red | ||
| API de configuración del sistema operativo | ||
| Iniciar sesión en el sistema operativo | ||
| Política de organización | ||
| Perfilador | ||
| Pub/Sub | ||
| Conector Kafka del grupo Pub/Sub | ||
| Pub/Sub Lite | ||
| Pub/Sub Lite Kafka Shim | ||
| Conector Spark Pub/Sub Lite | ||
| API de autoridad de certificación pública | ||
| API de cuotas | ||
| Recomendador | ||
| Redis | ||
| API del administrador de recursos | ||
| API de configuración de recursos | ||
| Minorista | ||
| API de rutas | ||
| Programador | ||
| Gestión Secreta | ||
| API de administrador de fuente segura | ||
| API de administración del centro de seguridad | ||
| Centro de comando de seguridad | ||
| API de postura de seguridad | ||
| Escáner de seguridad | ||
| Acceso a VPC sin servidor | ||
| API de control de servicios | ||
| Directorio de servicios | ||
| API de gestión de servicios | ||
| Uso del servicio | ||
| Caparazón | ||
| Llave | ||
| Llave JDBC | ||
| Discurso | ||
| Monitoreo de controlador de pila | ||
| Seguimiento del controlador de pila | ||
| Almacenamiento | ||
| Servicio de transferencia de almacenamiento | ||
| TPU | ||
| Solución de talento | ||
| Tareas | ||
| API de automatización de telecomunicaciones | ||
| Texto a voz | ||
| Traducción | ||
| Migración de máquinas virtuales | ||
| IA de vértice | ||
| API de VertexAI | ||
| Videointeligencia | ||
| API de agrupación de vídeos | ||
| Transcodificador de vídeo | ||
| Visión | ||
| Riesgo web | ||
| Ejecuciones de flujo de trabajo | ||
| Flujos de trabajo | ||
| API de complementos del espacio de trabajo | ||
| Estaciones de trabajo | ||
| Empresa reCAPTCHA | ||
| API del centro API | ||
| API del administrador de anuncios | ||
| API de validación de direcciones | ||
| Administrador de análisis | ||
| Datos analíticos | ||
| Centro de análisis | ||
| Anthos Multinube | ||
| Servicio administrado para la API de Apache Kafka | ||
| API del centro de aplicaciones | ||
| Área 120 Mesas | ||
| Copia de seguridad para GKE | ||
| Solución de metal desnudo | ||
| Lote | ||
| Conexiones de la aplicación BeyondCorp | ||
| Conectores de aplicaciones BeyondCorp | ||
| Pasarelas de aplicaciones BeyondCorp | ||
| BeyondCorp ClientConnectorServicios | ||
| Pasarelas de cliente BeyondCorp | ||
| gran lago | ||
| API de política de datos de BigQuery | ||
| Migración de BigQuery | ||
| API CSS | ||
| Administrador de certificados | ||
| API de chat | ||
| Comercio Consumo Compras | ||
| API de informática confidencial | ||
| Conectar API de puerta de enlace | ||
| Etiquetado de datos | ||
| Flujo de datos | ||
| formulario de datos | ||
| API de conexión para desarrolladores | ||
| Flujo de diálogo CX | ||
| Almacén de documentos AI | ||
| Gráfico de conocimiento empresarial | ||
| Informe de errores | ||
| Editorial Eventarc | ||
| API de gestión de hardware de GDC | ||
| API de inventario KMS | ||
| Ciencias de la vida | ||
| API de transmisión en vivo | ||
| Appender de inicio de sesión | ||
| Inicializador de servlet de registro | ||
| API de conjuntos de datos de Maps Platform | ||
| API de administración de la plataforma de marketing | ||
| API de traducción de medios | ||
| Conoce la API | ||
| Almacén de memoria para la API de Redis | ||
| API comercial | ||
| API comercial | ||
| API comercial | ||
| API comercial | ||
| API comercial | ||
| API comercial | ||
| API de conversiones de comerciantes | ||
| API LFP para comerciantes | ||
| API de notificaciones para comerciantes | ||
| API de cuota de comerciante | ||
| API del Centro de Migración | ||
| Supervisión de alcances de métricas | ||
| Proveedor de sistema de archivos NIO para almacenamiento | ||
| API de NetApp | ||
| API de servicios de red | ||
| Base de datos Oracle@API | ||
| API de almacén paralelo | ||
| Protección contra phishing | ||
| API de lugares (nueva) | ||
| API de estadísticas de lugares | ||
| API del simulador de políticas | ||
| Catálogo Privado | ||
| API de administrador de acceso privilegiado | ||
| Conector Flink Pub/Sub Lite | ||
| API de evaluación de migración rápida | ||
| Recomendaciones IA | ||
| API de registro | ||
| API de optimización de ruta | ||
| Correr | ||
| API de configuración del centro de comando de seguridad | ||
| API de estado del servicio | ||
| API solares | ||
| API de información sobre almacenamiento | ||
| API de soporte | ||
| Motor VMware | ||
| API de visión AI | ||
| API de eventos del espacio de trabajo |
Si el servicio no aparece en la lista, google-api-java-client interactúa con API de Google Cloud adicionales mediante una interfaz REST heredada.
Al crear aplicaciones Java, se debe dar preferencia a las bibliotecas enumeradas en la tabla.
La mayoría de las bibliotecas google-cloud requieren un ID de proyecto. Hay varias formas de especificar este ID de proyecto.
google-cloud desde Compute/App Engine, no es necesario especificar un ID de proyecto. Se infiere automáticamente del entorno de producción.google-cloud en otro lugar, puede realizar una de las siguientes acciones:Proporcione el ID del proyecto al crear las opciones de servicio. Por ejemplo, para utilizar Datastore desde un proyecto con ID "PROJECT_ID", puedes escribir:
Datastore datastore = DatastoreOptions . newBuilder (). setProjectId ( "PROJECT_ID" ). build (). getService (); Especifique la variable de entorno GOOGLE_CLOUD_PROJECT como su ID de proyecto deseado.
Configure el ID del proyecto utilizando el SDK de Google Cloud. Para usar el SDK, descárguelo si aún no lo ha hecho y configure el ID del proyecto desde la línea de comando. Por ejemplo:
gcloud config set project PROJECT_ID
google-cloud determina el ID del proyecto a partir de las siguientes fuentes en el orden enumerado y se detiene una vez que encuentra un valor:
GOOGLE_CLOUD_PROJECTGOOGLE_APPLICATION_CREDENTIALSEn los casos en los que la biblioteca puede esperar explícitamente un ID de proyecto, proporcionamos un asistente que puede proporcionar el ID de proyecto inferido:
import com . google . cloud . ServiceOptions ;
...
String projectId = ServiceOptions . getDefaultProjectId (); google-cloud-java utiliza https://github.com/googleapis/google-auth-library-java para autenticar solicitudes. google-auth-library-java admite una amplia gama de tipos de autenticación; consulte el README y el javadoc del proyecto para obtener más detalles.
Cuando se utilizan bibliotecas de Google Cloud desde un entorno de Google Cloud Platform como Compute Engine, Kubernetes Engine o App Engine, no se necesitan pasos de autenticación adicionales.
Por ejemplo:
Storage storage = StorageOptions . getDefaultInstance (). getService ();o:
CloudTasksClient cloudTasksClient = CloudTasksClient . create ();Genere una clave de cuenta de servicio JSON.
Después de descargar esa clave, debes hacer una de las siguientes cosas:
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 se ejecuta localmente para desarrollo/pruebas, puede utilizar el SDK de Google Cloud. Cree credenciales predeterminadas de la aplicación con gcloud auth application-default login y luego google-cloud detectará automáticamente dichas credenciales.
Si ya tiene un token de acceso OAuth2, puede usarlo para autenticarse (tenga en cuenta que, en este caso, el token de acceso no se actualizará automáticamente):
Credentials credentials = GoogleCredentials . create ( new AccessToken ( accessToken , expirationTime ));
Storage storage = StorageOptions . newBuilder ()
. setCredentials ( credentials )
. build ()
. getService ();o:
Credentials credentials = GoogleCredentials . create ( new AccessToken ( accessToken , expirationTime ));
CloudTasksSettings cloudTasksSettings = CloudTasksSettings . newBuilder ()
. setCredentialProvider ( FixedCredentialsProvider . create ( credentials ))
. build ();
CloudTasksClient cloudTasksClient = CloudTasksClient . create ( cloudTasksSettings ); Si no se proporcionan credenciales, google-cloud intentará detectarlas desde el entorno utilizando GoogleCredentials.getApplicationDefault() , que buscará las credenciales predeterminadas de la aplicación en las siguientes ubicaciones (en orden):
GOOGLE_APPLICATION_CREDENTIALSgcloud auth application-default login del SDK de Google CloudLa autenticación con claves API es compatible con varias API de Google Cloud.
Estamos explorando activamente formas de mejorar la experiencia de la clave API. Actualmente, para utilizar una clave API con una biblioteca de cliente Java, debe configurar manualmente el encabezado para el cliente de servicio correspondiente.
Por ejemplo, para configurar la clave API con el servicio de idioma:
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 ejemplo de creación de instancias con Language Client usando 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 ;
}Para obtener ayuda, siga las instrucciones del documento de solución de problemas.
Las bibliotecas cliente de Google Cloud utilizan HTTPS y gRPC en la comunicación subyacente con los servicios. En ambos protocolos, puede configurar un proxy utilizando las propiedades https.proxyHost y (opcional) https.proxyPort .
Para un proxy más personalizado con gRPC, necesitará proporcionar un ProxyDetector al 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 );
} Las operaciones de larga duración (LRO) se utilizan a menudo para llamadas API que se espera que tarden mucho tiempo en completarse (es decir, aprovisionar una instancia de GCE o una canalización de flujo de datos). La llamada API inicial crea una "operación" en el servidor y devuelve un ID de operación para realizar un seguimiento de su progreso. Los RPC de LRO tienen el sufijo Async añadido al nombre de la llamada (es decir, clusterControllerClient.createClusterAsync() ).
Nuestros clientes generados proporcionan una interfaz agradable para iniciar la operación y luego esperar a que se complete. Esto se logra devolviendo un OperationFuture . Al llamar a get() en OperationFuture , la biblioteca cliente sondeará la operación para verificar su estado.
Por ejemplo, tome una operación createCluster de muestra en 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.
} Las operaciones de sondeo tienen un tiempo de espera predeterminado que varía de un servicio a otro. La biblioteca generará una excepción java.util.concurrent.CancellationException con el mensaje: Task was cancelled. si el tiempo de espera excede la operación. Una CancellationException no significa que la operación de GCP del backend haya sido cancelada. Esta excepción se genera desde la biblioteca del cliente cuando ha excedido el tiempo de espera total sin recibir un estado exitoso de la operación. Nuestras bibliotecas cliente respetan los valores configurados establecidos en OperationTimedPollAlgorithm para cada RPC.
Nota: La biblioteca cliente maneja el mecanismo de sondeo de la Operación por usted. De forma predeterminada, no es necesario sondear manualmente el estado usted mismo.
Cada LRO RPC tiene un conjunto de valores predeterminados preconfigurados. Puede encontrar estos valores buscando en la clase StubSettings de cada Cliente. La configuración predeterminada de LRO se inicializa dentro del método initDefaults() en la clase Builder anidada.
Por ejemplo, en google-cloud-aiplatform v3.24.0, el OperationTimedPollAlgorithm predeterminado tiene estos valores predeterminados:
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 ())Tanto los reintentos como los LRO comparten la misma clase RetrySettings. Tenga en cuenta el enlace correspondiente:
Los valores de tiempo de espera de RPC no se utilizan en LRO y se pueden omitir o establecer en los valores predeterminados ( Duration.ZERO para tiempos de espera o 1.0 para el multiplicador).
Para configurar los valores de LRO, cree un objeto OperationTimedPollAlgorithm y actualice el algoritmo de sondeo de RPC. Por ejemplo:
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 ()); Nota: La configuración anterior solo modifica los valores de LRO para createClusterOperation RPC. Los otros RPC en el Cliente seguirán usando los valores LRO preconfigurados de cada RPC.
Si utiliza más de una biblioteca cliente de Google Cloud, le recomendamos utilizar uno de nuestros artefactos de lista de materiales (BOM) para ayudar a administrar las versiones de dependencia. Para obtener más información, consulte Uso de las bibliotecas cliente de la nube.
Se requiere Java 8 o superior para utilizar los clientes en este repositorio.
Los clientes de este repositorio utilizan HTTP o gRPC para la capa de transporte. Todos los clientes basados en HTTP deberían funcionar en todos los entornos.
Para los clientes que usan gRPC, las plataformas admitidas están restringidas por las plataformas que admite Forked Tomcat Native, lo que para arquitecturas significa solo x86_64 y para sistemas operativos significa Mac OS X, Windows y Linux. Además, gRPC restringe el uso de plataformas con restricciones de subprocesos.
Por lo tanto, no se admiten los siguientes:
Los siguientes entornos deberían funcionar (entre otros):
Esta biblioteca proporciona herramientas para ayudar a escribir pruebas de código que utiliza los servicios de la nube de Google.
Consulte PRUEBAS para leer más sobre el uso de nuestros asistentes de prueba.
Esta biblioteca sigue el control de versiones semántico, con algunas calificaciones adicionales:
Los componentes marcados con @BetaApi o @Experimental se consideran características "0.x" dentro de una biblioteca "1.x". Esto significa que pueden cambiar entre versiones menores y de parches de forma incompatible. Estas funciones no deben ser utilizadas por ninguna biblioteca "B" que tenga consumidores, a menos que los componentes de la biblioteca B que usan funciones @BetaApi también estén marcados con @BetaApi . Las funciones marcadas como @BetaApi están en camino de convertirse eventualmente en funciones "1.x" con el marcador eliminado.
Excepción especial para google-cloud-java : google-cloud-java puede depender de las características @BetaApi en gax-java sin declarar el código de consumo @BetaApi , porque gax-java y google-cloud-java se mueven al mismo tiempo. . Por este motivo, gax-java no debe utilizarse independientemente de google-cloud-java.
Los componentes marcados con @InternalApi son técnicamente públicos, pero sólo debido a las limitaciones de los modificadores de acceso de Java. A los efectos de semver, deben considerarse privados.
Las interfaces marcadas con @InternalExtensionOnly son públicas, pero solo deben implementarse mediante clases internas. A los efectos de semver, nos reservamos el derecho de agregar a estas interfaces sin implementaciones predeterminadas (para Java 7).
Tenga en cuenta que estos clientes se encuentran actualmente en desarrollo activo. Cualquier versión con versión 0.xy está sujeta a cambios incompatibles con versiones anteriores en cualquier momento.
Se espera que las bibliotecas definidas con un nivel de calidad Estable sean estables y se garantiza que todas las actualizaciones de las bibliotecas serán compatibles con versiones anteriores. Cualquier cambio incompatible con versiones anteriores dará lugar al incremento de la versión principal (1.xy -> 2.0.0).
Las bibliotecas definidas en un nivel de calidad de Vista previa aún son un trabajo en progreso y es más probable que obtengan actualizaciones incompatibles con versiones anteriores. Además, es posible que las bibliotecas de Vista previa queden obsoletas y eliminadas antes de ser promovidas a Vista previa o Estable.
Si está utilizando IntelliJ o Eclipse, puede agregar bibliotecas cliente a su proyecto usando estos complementos IDE:
Además de agregar bibliotecas de clientes, los complementos brindan funciones adicionales, como la administración de claves de cuentas de servicio. Consulte la documentación de cada complemento para obtener más detalles.
Estas bibliotecas cliente se pueden usar en App Engine estándar para el tiempo de ejecución de Java 8 y App Engine flexible (incluido el tiempo de ejecución de Compat). La mayoría de las bibliotecas no funcionan en el estándar App Engine para el tiempo de ejecución de Java 7. Sin embargo, Datastore, Storage y Bigquery deberían funcionar.
Las contribuciones a esta biblioteca siempre son bienvenidas y muy recomendables.
Consulte la documentación CONTRIBUYENTE de google-cloud y la documentación compartida para obtener más información sobre cómo comenzar.
Tenga en cuenta que este proyecto se publica con un Código de conducta para colaboradores. Al participar en este proyecto, usted acepta cumplir con sus términos. Consulte el Código de conducta para obtener más información.
Apache 2.0: consulte LICENCIA para obtener más información.
