go: cloud.google.com/go

Package cloud is the root of the packages used to access Google Cloud Services. See https://pkg.go.dev/cloud.google.com/go for a full list of sub-modules. All clients in sub-packages are configurable via client options. These options are described here: https://pkg.go.dev/google.golang.org/api/option. Endpoint configuration is used to specify the URL to which requests are sent. It is used for services that support or require regional endpoints, as well as for other use cases such as testing against fake servers. For example, the Vertex AI service recommends that you configure the endpoint to the location with the features you want that is closest to your physical location or the location of your users. There is no global endpoint for Vertex AI. See Vertex AI - Locations for more details. The following example demonstrates configuring a Vertex AI client with a regional endpoint: All of the clients support authentication via Google Application Default Credentials, or by providing a JSON key file for a Service Account. See examples below. Google Application Default Credentials (ADC) is the recommended way to authorize and authenticate clients. For information on how to create and obtain Application Default Credentials, see https://cloud.google.com/docs/authentication/production. If you have your environment configured correctly you will not need to pass any extra information to the client libraries. Here is an example of a client using ADC to authenticate: You can use a file with credentials to authenticate and authorize, such as a JSON key file associated with a Google service account. Service Account keys can be created and downloaded from https://console.cloud.google.com/iam-admin/serviceaccounts. This example uses the Secret Manger client, but the same steps apply to the all other client libraries this package as well. Example: In some cases (for instance, you don't want to store secrets on disk), you can create credentials from in-memory JSON and use the WithCredentials option. This example uses the Secret Manager client, but the same steps apply to all other client libraries as well. Note that scopes can be found at https://developers.google.com/identity/protocols/oauth2/scopes, and are also provided in all auto-generated libraries: for example, cloud.google.com/go/secretmanager/apiv1 provides DefaultAuthScopes. Example: By default, non-streaming methods, like Create or Get, will have a default deadline applied to the context provided at call time, unless a context deadline is already set. Streaming methods have no default deadline and will run indefinitely. To set timeouts or arrange for cancellation, use context. Transient errors will be retried when correctness allows. Here is an example of setting a timeout for an RPC using context.WithTimeout: Here is an example of setting a timeout for an RPC using github.com/googleapis/gax-go/v2.WithTimeout: Here is an example of how to arrange for an RPC to be canceled, use context.WithCancel: Do not attempt to control the initial connection (dialing) of a service by setting a timeout on the context passed to NewClient. Dialing is non-blocking, so timeouts would be ineffective and would only interfere with credential refreshing, which uses the same context. Regardless of which transport is used, request headers can be set in the same way using [`callctx.SetHeaders`]setheaders. Here is a generic example: ## Google-reserved headers There are a some header keys that Google reserves for internal use that must not be ovewritten. The following header keys are broadly considered reserved and should not be conveyed by client library users unless instructed to do so: * `x-goog-api-client` * `x-goog-request-params` Be sure to check the individual package documentation for other service-specific reserved headers. For example, Storage supports a specific auditing header that is mentioned in that [module's documentation]storagedocs. ## Google Cloud system parameters Google Cloud services respect system parameterssystem parameters that can be used to augment request and/or response behavior. For the most part, they are not needed when using one of the enclosed client libraries. However, those that may be necessary are made available via the [`callctx`]callctx package. If not present there, consider opening an issue on that repo to request a new constant. Connection pooling differs in clients based on their transport. Cloud clients either rely on HTTP or gRPC transports to communicate with Google Cloud. Cloud clients that use HTTP rely on the underlying HTTP transport to cache connections for later re-use. These are cached to the http.MaxIdleConns and http.MaxIdleConnsPerHost settings in http.DefaultTransport by default. For gRPC clients, connection pooling is configurable. Users of Cloud Client Libraries may specify option.WithGRPCConnectionPool(n) as a client option to NewClient calls. This configures the underlying gRPC connections to be pooled and accessed in a round robin fashion. Minimal container images like Alpine lack CA certificates. This causes RPCs to appear to hang, because gRPC retries indefinitely. See https://github.com/googleapis/google-cloud-go/issues/928 for more information. For tips on how to write tests against code that calls into our libraries check out our Debugging Guide. For tips on how to write tests against code that calls into our libraries check out our Testing Guide. Most of the errors returned by the generated clients are wrapped in an github.com/googleapis/gax-go/v2/apierror.APIError and can be further unwrapped into a google.golang.org/grpc/status.Status or google.golang.org/api/googleapi.Error depending on the transport used to make the call (gRPC or REST). Converting your errors to these types can be a useful way to get more information about what went wrong while debugging. APIError gives access to specific details in the error. The transport-specific errors can still be unwrapped using the APIError. If the gRPC transport was used, the google.golang.org/grpc/status.Status can still be parsed using the google.golang.org/grpc/status.FromError function. Semver is used to communicate stability of the sub-modules of this package. Note, some stable sub-modules do contain packages, and sometimes features, that are considered unstable. If something is unstable it will be explicitly labeled as such. Example of package does in an unstable package: Clients that contain alpha and beta in their import path may change or go away without notice. Clients marked stable will maintain compatibility with future versions for as long as we can reasonably sustain. Incompatible changes might be made in some situations, including:

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.116.0 (published 2 months ago)
• Last Synced: 2024-11-13T12:01:03.072Z (about 1 month ago)
• Versions: 153
• Dependent Packages: 28,537
• Dependent Repositories: 156,705
• Docker Downloads: 38,723,983,444
• Rankings:
  • Dependent repos count: 0.003%
  • Dependent packages count: 0.007%
  • Docker downloads count: 0.009%
  • Average: 0.385%
  • Forks count: 0.738%
  • Stargazers count: 1.168%

go: cloud.google.com/go/storage

Package storage provides an easy way to work with Google Cloud Storage. Google Cloud Storage stores data in named objects, which are grouped into buckets. More information about Google Cloud Storage is available at https://cloud.google.com/storage/docs. See https://pkg.go.dev/cloud.google.com/go for authentication, timeouts, connection pooling and similar aspects of this package. To start working with this package, create a Client: The client will use your default application credentials. Clients should be reused instead of created as needed. The methods of Client are safe for concurrent use by multiple goroutines. You may configure the client by passing in options from the google.golang.org/api/option package. You may also use options defined in this package, such as WithJSONReads. If you only wish to access public data, you can create an unauthenticated client with To use an emulator with this library, you can set the STORAGE_EMULATOR_HOST environment variable to the address at which your emulator is running. This will send requests to that address instead of to Cloud Storage. You can then create and use a client as usual: Please note that there is no official emulator for Cloud Storage. A Google Cloud Storage bucket is a collection of objects. To work with a bucket, make a bucket handle: A handle is a reference to a bucket. You can have a handle even if the bucket doesn't exist yet. To create a bucket in Google Cloud Storage, call BucketHandle.Create: Note that although buckets are associated with projects, bucket names are global across all projects. Each bucket has associated metadata, represented in this package by BucketAttrs. The third argument to BucketHandle.Create allows you to set the initial BucketAttrs of a bucket. To retrieve a bucket's attributes, use BucketHandle.Attrs: An object holds arbitrary data as a sequence of bytes, like a file. You refer to objects using a handle, just as with buckets, but unlike buckets you don't explicitly create an object. Instead, the first time you write to an object it will be created. You can use the standard Go io.Reader and io.Writer interfaces to read and write object data: Objects also have attributes, which you can fetch with ObjectHandle.Attrs: Listing objects in a bucket is done with the BucketHandle.Objects method: Objects are listed lexicographically by name. To filter objects lexicographically, [Query.StartOffset] and/or [Query.EndOffset] can be used: If only a subset of object attributes is needed when listing, specifying this subset using Query.SetAttrSelection may speed up the listing process: Both objects and buckets have ACLs (Access Control Lists). An ACL is a list of ACLRules, each of which specifies the role of a user, group or project. ACLs are suitable for fine-grained control, but you may prefer using IAM to control access at the project level (see Cloud Storage IAM docs. To list the ACLs of a bucket or object, obtain an ACLHandle and call ACLHandle.List: You can also set and delete ACLs. Every object has a generation and a metageneration. The generation changes whenever the content changes, and the metageneration changes whenever the metadata changes. Conditions let you check these values before an operation; the operation only executes if the conditions match. You can use conditions to prevent race conditions in read-modify-write operations. For example, say you've read an object's metadata into objAttrs. Now you want to write to that object, but only if its contents haven't changed since you read it. Here is how to express that: You can obtain a URL that lets anyone read or write an object for a limited time. Signing a URL requires credentials authorized to sign a URL. To use the same authentication that was used when instantiating the Storage client, use BucketHandle.SignedURL. You can also sign a URL without creating a client. See the documentation of SignedURL for details. A type of signed request that allows uploads through HTML forms directly to Cloud Storage with temporary permission. Conditions can be applied to restrict how the HTML form is used and exercised by a user. For more information, please see the XML POST Object docs as well as the documentation of BucketHandle.GenerateSignedPostPolicyV4. If the GoogleAccessID and PrivateKey option fields are not provided, they will be automatically detected by BucketHandle.SignedURL and BucketHandle.GenerateSignedPostPolicyV4 if any of the following are true: Detecting GoogleAccessID may not be possible if you are authenticated using a token source or using option.WithHTTPClient. In this case, you can provide a service account email for GoogleAccessID and the client will attempt to sign the URL or Post Policy using that service account. To generate the signature, you must have: Errors returned by this client are often of the type googleapi.Error. These errors can be introspected for more information by using errors.As with the richer googleapi.Error type. For example: Methods in this package may retry calls that fail with transient errors. Retrying continues indefinitely unless the controlling context is canceled, the client is closed, or a non-transient error is received. To stop retries from continuing, use context timeouts or cancellation. The retry strategy in this library follows best practices for Cloud Storage. By default, operations are retried only if they are idempotent, and exponential backoff with jitter is employed. In addition, errors are only retried if they are defined as transient by the service. See the Cloud Storage retry docs for more information. Users can configure non-default retry behavior for a single library call (using BucketHandle.Retryer and ObjectHandle.Retryer) or for all calls made by a client (using Client.SetRetry). For example: You can add custom headers to any API call made by this package by using callctx.SetHeaders on the context which is passed to the method. For example, to add a custom audit logging header: This package includes support for the Cloud Storage gRPC API. The implementation uses gRPC rather than the Default JSON & XML APIs to make requests to Cloud Storage. The Go Storage gRPC client is generally available. The Notifications, Serivce Account HMAC and GetServiceAccount RPCs are not supported through the gRPC client. To create a client which will use gRPC, use the alternate constructor: Using the gRPC API inside GCP with a bucket in the same region can allow for Direct Connectivity (enabling requests to skip some proxy steps and reducing response latency). A warning is emmitted if gRPC is not used within GCP to warn that Direct Connectivity could not be initialized. Direct Connectivity is not required to access the gRPC API. Dependencies for the gRPC API may slightly increase the size of binaries for applications depending on this package. If you are not using gRPC, you can use the build tag `disable_grpc_modules` to opt out of these dependencies and reduce the binary size. The gRPC client emits metrics by default and will export the gRPC telemetry discussed in gRFC/66 and gRFC/78 to Google Cloud Monitoring. The metrics are accessible through Cloud Monitoring API and you incur no additional cost for publishing the metrics. Google Cloud Support can use this information to more quickly diagnose problems related to GCS and gRPC. Sending this data does not incur any billing charges, and requires minimal CPU (a single RPC every minute) or memory (a few KiB to batch the telemetry). To access the metrics you can view them through Cloud Monitoring metric explorer with the prefix `storage.googleapis.com/client`. Metrics are emitted every minute. You can disable metrics using the following example when creating a new gRPC client using WithDisabledClientMetrics. The metrics exporter uses Cloud Monitoring API which determines project ID and credentials doing the following: * Project ID is determined using OTel Resource Detector for the environment otherwise it falls back to the project provided by google.FindCredentials. * Credentials are determined using Application Default Credentials. The principal must have `roles/monitoring.metricWriter` role granted. If not a logged warning will be emitted. Subsequent are silenced to prevent noisy logs. Certain control plane and long-running operations for Cloud Storage (including Folder and Managed Folder operations) are supported via the autogenerated Storage Control client, which is available as a subpackage in this module. See package docs at cloud.google.com/go/storage/control/apiv2 or reference the Storage Control API docs.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/storage#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.46.0 (published about 2 months ago)
• Last Synced: 2024-11-13T03:31:20.113Z (about 1 month ago)
• Versions: 59
• Dependent Packages: 10,001
• Dependent Repositories: 100,575
• Docker Downloads: 16,249,501,616
• Rankings:
  • Dependent repos count: 0.011%
  • Dependent packages count: 0.023%
  • Docker downloads count: 0.024%
  • Average: 0.385%
  • Forks count: 0.714%
  • Stargazers count: 1.156%

go: cloud.google.com/go/compute/metadata

Package metadata provides access to Google Compute Engine (GCE) metadata and API service accounts. This package is a wrapper around the GCE metadata service, as documented at https://cloud.google.com/compute/docs/metadata/overview.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/compute/metadata#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.2.3 (published about 2 years ago)
• Last Synced: 2024-11-11T12:01:19.181Z (about 1 month ago)
• Versions: 11
• Dependent Packages: 11,122
• Dependent Repositories: 14,375
• Docker Downloads: 28,381,315,988
• Rankings:
  • Docker downloads count: 0.016%
  • Dependent packages count: 0.024%
  • Dependent repos count: 0.06%
  • Average: 0.399%
  • Forks count: 0.728%
  • Stargazers count: 1.167%

go: cloud.google.com/go/iam

Package iam supports the resource-specific operations of Google Cloud IAM (Identity and Access Management) for the Google Cloud Libraries. See https://cloud.google.com/iam for more about IAM. Users of the Google Cloud Libraries will typically not use this package directly. Instead they will begin with some resource that supports IAM, like a pubsub topic, and call its IAM method to get a Handle for that resource.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/iam#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.2.2 (published about 2 months ago)
• Last Synced: 2024-11-13T05:04:33.023Z (about 1 month ago)
• Versions: 33
• Dependent Packages: 8,564
• Dependent Repositories: 13,902
• Docker Downloads: 17,949,252,012
• Rankings:
  • Docker downloads count: 0.021%
  • Dependent packages count: 0.032%
  • Dependent repos count: 0.062%
  • Average: 0.402%
  • Forks count: 0.728%
  • Stargazers count: 1.169%

go: cloud.google.com/go/compute

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/compute#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.28.3 (published about 1 month ago)
• Last Synced: 2024-11-14T04:30:33.487Z (about 1 month ago)
• Versions: 48
• Dependent Packages: 14,312
• Dependent Repositories: 19,950
• Docker Downloads: 11,012,538,847
• Rankings:
  • Dependent packages count: 0.017%
  • Docker downloads count: 0.039%
  • Dependent repos count: 0.047%
  • Average: 0.407%
  • Forks count: 0.748%
  • Stargazers count: 1.185%

go: cloud.google.com/go/pubsub

Package pubsub provides an easy way to publish and receive Google Cloud Pub/Sub messages, hiding the details of the underlying server RPCs. Pub/Sub is a many-to-many, asynchronous messaging system that decouples senders and receivers. More information about Pub/Sub is available at https://cloud.google.com/pubsub/docs See https://godoc.org/cloud.google.com/go for authentication, timeouts, connection pooling and similar aspects of this package. Pub/Sub messages are published to topics. A Topic may be created using Client.CreateTopic like so: Messages may then be published to a Topic: Topic.Publish queues the message for publishing and returns immediately. When enough messages have accumulated, or enough time has elapsed, the batch of messages is sent to the Pub/Sub service. Topic.Publish returns a PublishResult, which behaves like a future: its Get method blocks until the message has been sent to the service. The first time you call Topic.Publish on a Topic, goroutines are started in the background. To clean up these goroutines, call Topic.Stop: To receive messages published to a Topic, clients create a Subscription for the topic. There may be more than one subscription per topic ; each message that is published to the topic will be delivered to all associated subscriptions. A Subscription may be created like so: Messages are then consumed from a Subscription via callback. The callback is invoked concurrently by multiple goroutines, maximizing throughput. To terminate a call to Subscription.Receive, cancel its context. Once client code has processed the Message, it must call Message.Ack or Message.Nack; otherwise the Message will eventually be redelivered. Ack/Nack MUST be called within the Subscription.Receive handler function, and not from a goroutine. Otherwise, flow control (e.g. ReceiveSettings.MaxOutstandingMessages) will not be respected, and messages can get orphaned when cancelling Receive. If the client cannot or doesn't want to process the message, it can call Message.Nack to speed redelivery. For more information and configuration options, see Ack Deadlines below. Note: It is possible for a Message to be redelivered even if Message.Ack has been called. Client code must be robust to multiple deliveries of messages. Note: This uses pubsub's streaming pull feature. This feature has properties that may be surprising. Please take a look at https://cloud.google.com/pubsub/docs/pull#streamingpull for more details on how streaming pull behaves compared to the synchronous pull method. The number of StreamingPull connections can be configured by setting NumGoroutines in ReceiveSettings. The default value of 10 means the client library will maintain 10 StreamingPull connections. This is more than sufficient for most use cases, as StreamingPull connections can handle up to 10 MB/s https://cloud.google.com/pubsub/quotas#resource_limits. In some cases, using too many streams can lead to client library behaving poorly as the application becomes I/O bound. By default, the number of connections in the gRPC conn pool is min(4,GOMAXPROCS). Each connection supports up to 100 streams. Thus, if you have 4 or more CPU cores, the default setting allows a maximum of 400 streams which is already excessive for most use cases. If you want to change the limits on the number of streams, you can change the number of connections in the gRPC connection pool as shown below: The default pubsub deadlines are suitable for most use cases, but may be overridden. This section describes the tradeoffs that should be considered when overriding the defaults. Behind the scenes, each message returned by the Pub/Sub server has an associated lease, known as an "ack deadline". Unless a message is acknowledged within the ack deadline, or the client requests that the ack deadline be extended, the message will become eligible for redelivery. As a convenience, the pubsub client will automatically extend deadlines until either: Ack deadlines are extended periodically by the client. The period between extensions, as well as the length of the extension, automatically adjusts based on the time it takes the subscriber application to ack messages (based on the 99th percentile of ack latency). By default, this extension period is capped at 10m, but this limit can be configured by the "MaxExtensionPeriod" setting. This has the effect that subscribers that process messages quickly have their message ack deadlines extended for a short amount, whereas subscribers that process message slowly have their message ack deadlines extended for a large amount. The net effect is fewer RPCs sent from the client library. For example, consider a subscriber that takes 3 minutes to process each message. Since the library has already recorded several 3-minute "ack latencies"s in a percentile distribution, future message extensions are sent with a value of 3 minutes, every 3 minutes. Suppose the application crashes 5 seconds after the library sends such an extension: the Pub/Sub server would wait the remaining 2m55s before re-sending the messages out to other subscribers. Please note that by default, the client library does not use the subscription's AckDeadline for the MaxExtension value. For use cases where message processing exceeds 30 minutes, we recommend using the base client in a pull model, since long-lived streams are periodically killed by firewalls. See the example at https://godoc.org/cloud.google.com/go/pubsub/apiv1#example-SubscriberClient-Pull-LengthyClientProcessing To use an emulator with this library, you can set the PUBSUB_EMULATOR_HOST environment variable to the address at which your emulator is running. This will send requests to that address instead of to Pub/Sub. You can then create and use a client as usual:

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/pubsub#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.35.0 (published 11 months ago)
• Last Synced: 2024-11-10T13:31:04.280Z (about 1 month ago)
• Versions: 78
• Dependent Packages: 2,645
• Dependent Repositories: 100,525
• Docker Downloads: 2,842,339,406
• Rankings:
  • Dependent repos count: 0.011%
  • Dependent packages count: 0.077%
  • Docker downloads count: 0.09%
  • Average: 0.415%
  • Forks count: 0.731%
  • Stargazers count: 1.169%

go: cloud.google.com/go/bigquery

Package bigquery provides a client for the BigQuery service. The following assumes a basic familiarity with BigQuery concepts. See https://cloud.google.com/bigquery/docs. See https://godoc.org/cloud.google.com/go for authentication, timeouts, connection pooling and similar aspects of this package. To start working with this package, create a client with NewClient: To query existing tables, create a Client.Query and call its Query.Read method, which starts the query and waits for it to complete: Then iterate through the resulting rows. You can store a row using anything that implements the ValueLoader interface, or with a slice or map of Value. A slice is simplest: You can also use a struct whose exported fields match the query: You can also start the query running and get the results later. Create the query as above, but call Query.Run instead of Query.Read. This returns a Job, which represents an asynchronous operation. Get the job's ID, a printable string. You can save this string to retrieve the results at a later time, even in another process. To retrieve the job's results from the ID, first look up the Job with the Client.JobFromID method: Use the Job.Read method to obtain an iterator, and loop over the rows. Calling Query.Read is preferred for queries with a relatively small result set, as it will call BigQuery jobs.query API for a optimized query path. If the query doesn't meet that criteria, the method will just combine Query.Run and Job.Read. You can refer to datasets in the client's project with the Client.Dataset method, and in other projects with the Client.DatasetInProject method: These methods create references to datasets, not the datasets themselves. You can have a dataset reference even if the dataset doesn't exist yet. Use Dataset.Create to create a dataset from a reference: You can refer to tables with Dataset.Table. Like Dataset, Table is a reference to an object in BigQuery that may or may not exist. You can create, delete and update the metadata of tables with methods on Table. For instance, you could create a temporary table with: We'll see how to create a table with a schema in the next section. There are two ways to construct schemas with this package. You can build a schema by hand with the Schema struct, like so: Or you can infer the schema from a struct with the InferSchema method: Struct inference supports tags like those of the encoding/json package, so you can change names, ignore fields, or mark a field as nullable (non-required). Fields declared as one of the Null types (NullInt64, NullFloat64, NullString, NullBool, NullTimestamp, NullDate, NullTime, NullDateTime, NullGeography, and NullJSON) are automatically inferred as nullable, so the "nullable" tag is only needed for []byte, *big.Rat and pointer-to-struct fields. Having constructed a schema, you can create a table with it using the Table.Create method like so: You can copy one or more tables to another table. Begin by constructing a Copier describing the copy using the Table.CopierFrom. Then set any desired copy options, and finally call Copier.Run to get a Job: You can chain the call to Copier.Run if you don't want to set options: You can wait for your job to complete with the Job.Wait method: Job.Wait polls with exponential backoff. You can also poll yourself, if you wish: There are two ways to populate a table with this package: load the data from a Google Cloud Storage object, or upload rows directly from your program. For loading, first create a GCSReference with the NewGCSReference method, configuring it if desired. Then make a Loader from a table with the Table.LoaderFrom method with the reference, optionally configure it as well, and call its Loader.Run method. To upload, first define a type that implements the ValueSaver interface, which has a single method named Save. Then create an Inserter, and call its Inserter.Put method with a slice of values. You can also upload a struct that doesn't implement ValueSaver. Use the StructSaver type to specify the schema and insert ID by hand: Lastly, but not least, you can just supply the struct or struct pointer directly and the schema will be inferred: BigQuery allows for higher throughput when omitting insertion IDs. To enable this, specify the sentinel NoDedupeID value for the insertion ID when implementing a ValueSaver. If you've been following so far, extracting data from a BigQuery table into a Google Cloud Storage object will feel familiar. First create an Extractor, then optionally configure it, and lastly call its Extractor.Run method. Errors returned by this client are often of the type googleapi.Error. These errors can be introspected for more information by using errors.As with the richer googleapi.Error type. For example: In some cases, your client may received unstructured googleapi.Error error responses. In such cases, it is likely that you have exceeded BigQuery request limits, documented at: https://cloud.google.com/bigquery/quotas

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/bigquery#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.60.0 (published 9 months ago)
• Last Synced: 2024-11-11T17:33:10.615Z (about 1 month ago)
• Versions: 77
• Dependent Packages: 1,409
• Dependent Repositories: 101,387
• Docker Downloads: 2,720,459,884
• Rankings:
  • Dependent repos count: 0.01%
  • Docker downloads count: 0.088%
  • Dependent packages count: 0.115%
  • Average: 0.421%
  • Forks count: 0.726%
  • Stargazers count: 1.166%

go: cloud.google.com/go/kms

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/kms#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.16.0 (published 8 months ago)
• Last Synced: 2024-11-11T03:30:29.974Z (about 1 month ago)
• Versions: 43
• Dependent Packages: 1,484
• Dependent Repositories: 6,592
• Docker Downloads: 5,282,261,215
• Rankings:
  • Docker downloads count: 0.048%
  • Dependent repos count: 0.094%
  • Dependent packages count: 0.123%
  • Average: 0.434%
  • Forks count: 0.732%
  • Stargazers count: 1.174%

go: cloud.google.com/go/monitoring

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/monitoring#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.19.0 (published 8 months ago)
• Last Synced: 2024-11-11T14:32:03.694Z (about 1 month ago)
• Versions: 40
• Dependent Packages: 908
• Dependent Repositories: 4,048
• Docker Downloads: 2,025,198,293
• Rankings:
  • Docker downloads count: 0.096%
  • Dependent repos count: 0.13%
  • Dependent packages count: 0.155%
  • Average: 0.457%
  • Forks count: 0.732%
  • Stargazers count: 1.174%

go: cloud.google.com/go/trace

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/trace#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.10.7 (published 8 months ago)
• Last Synced: 2024-11-11T04:37:58.715Z (about 1 month ago)
• Versions: 26
• Dependent Packages: 773
• Dependent Repositories: 3,848
• Docker Downloads: 910,165,442
• Rankings:
  • Docker downloads count: 0.127%
  • Dependent repos count: 0.134%
  • Dependent packages count: 0.168%
  • Average: 0.465%
  • Forks count: 0.728%
  • Stargazers count: 1.167%

go: cloud.google.com/go/datastore

Package datastore provides a client for Google Cloud Datastore. See https://godoc.org/cloud.google.com/go for authentication, timeouts, connection pooling and similar aspects of this package. Entities are the unit of storage and are associated with a key. A key consists of an optional parent key, a string application ID, a string kind (also known as an entity type), and either a StringID or an IntID. A StringID is also known as an entity name or key name. It is valid to create a key with a zero StringID and a zero IntID; this is called an incomplete key, and does not refer to any saved entity. Putting an entity into the datastore under an incomplete key will cause a unique key to be generated for that entity, with a non-zero IntID. An entity's contents are a mapping from case-sensitive field names to values. Valid value types are: Slices of structs are valid, as are structs that contain slices. The Get and Put functions load and save an entity's contents. An entity's contents are typically represented by a struct pointer. Example code: GetMulti, PutMulti and DeleteMulti are batch versions of the Get, Put and Delete functions. They take a []*Key instead of a *Key, and may return a datastore.MultiError when encountering partial failure. Mutate generalizes PutMulti and DeleteMulti to a sequence of any Datastore mutations. It takes a series of mutations created with NewInsert, NewUpdate, NewUpsert and NewDelete and applies them. Datastore.Mutate uses non-transactional mode; if atomicity is required, use Transaction.Mutate instead. An entity's contents can be represented by a variety of types. These are typically struct pointers, but can also be any type that implements the PropertyLoadSaver interface. If using a struct pointer, you do not have to explicitly implement the PropertyLoadSaver interface; the datastore will automatically convert via reflection. If a struct pointer does implement PropertyLoadSaver then those methods will be used in preference to the default behavior for struct pointers. Struct pointers are more strongly typed and are easier to use; PropertyLoadSavers are more flexible. The actual types passed do not have to match between Get and Put calls or even across different calls to datastore. It is valid to put a *PropertyList and get that same entity as a *myStruct, or put a *myStruct0 and get a *myStruct1. Conceptually, any entity is saved as a sequence of properties, and is loaded into the destination value on a property-by-property basis. When loading into a struct pointer, an entity that cannot be completely represented (such as a missing field) will result in an ErrFieldMismatch error but it is up to the caller whether this error is fatal, recoverable or ignorable. By default, for struct pointers, all properties are potentially indexed, and the property name is the same as the field name (and hence must start with an upper case letter). Fields may have a `datastore:"name,options"` tag. The tag name is the property name, which must be one or more valid Go identifiers joined by ".", but may start with a lower case letter. An empty tag name means to just use the field name. A "-" tag name means that the datastore will ignore that field. The only valid options are "omitempty", "noindex" and "flatten". If the options include "omitempty" and the value of the field is an empty value, then the field will be omitted on Save. Empty values are defined as false, 0, a nil pointer, a nil interface value, the zero time.Time, and any empty slice or string. (Empty slices are never saved, even without "omitempty".) Other structs, including GeoPoint, are never considered empty. If options include "noindex" then the field will not be indexed. All fields are indexed by default. Strings or byte slices longer than 1500 bytes cannot be indexed; fields used to store long strings and byte slices must be tagged with "noindex" or they will cause Put operations to fail. For a nested struct field, the options may also include "flatten". This indicates that the immediate fields and any nested substruct fields of the nested struct should be flattened. See below for examples. To use multiple options together, separate them by a comma. The order does not matter. If the options is "" then the comma may be omitted. Example code: A field of slice type corresponds to a Datastore array property, except for []byte, which corresponds to a Datastore blob. Zero-length slice fields are not saved. Slice fields of length 1 or greater are saved as Datastore arrays. When a zero-length Datastore array is loaded into a slice field, the slice field remains unchanged. If a non-array value is loaded into a slice field, the result will be a slice with one element, containing the value. Loading a Datastore Null into a basic type (int, float, etc.) results in a zero value. Loading a Null into a slice of basic type results in a slice of size 1 containing the zero value. Loading a Null into a pointer field results in nil. Loading a Null into a field of struct type is an error. A struct field can be a pointer to a signed integer, floating-point number, string or bool. Putting a non-nil pointer will store its dereferenced value. Putting a nil pointer will store a Datastore Null property, unless the field is marked omitempty, in which case no property will be stored. Loading a Null into a pointer field sets the pointer to nil. Loading any other value allocates new storage with the value, and sets the field to point to it. If the struct contains a *datastore.Key field tagged with the name "__key__", its value will be ignored on Put. When reading the Entity back into the Go struct, the field will be populated with the *datastore.Key value used to query for the Entity. Example code: If the struct pointed to contains other structs, then the nested or embedded structs are themselves saved as Entity values. For example, given these definitions: then an Outer would have one property, Inner, encoded as an Entity value. Note: embedded struct fields must be named to be encoded as an Entity. For example, in case of a type Outer with an embedded field Inner: all the Inner struct fields will be treated as fields of Outer itself. If an outer struct is tagged "noindex" then all of its implicit flattened fields are effectively "noindex". If the Inner struct contains a *Key field with the name "__key__", like so: then the value of K will be used as the Key for Inner, represented as an Entity value in datastore. If any nested struct fields should be flattened, instead of encoded as Entity values, the nested struct field should be tagged with the "flatten" option. For example, given the following: an Outer's properties would be equivalent to those of: Note that the "flatten" option cannot be used for Entity value fields or PropertyLoadSaver implementers. The server will reject any dotted field names for an Entity value. An entity's contents can also be represented by any type that implements the PropertyLoadSaver interface. This type may be a struct pointer, but it does not have to be. The datastore package will call Load when getting the entity's contents, and Save when putting the entity's contents. Possible uses include deriving non-stored fields, verifying fields, or indexing a field only if its value is positive. Example code: The *PropertyList type implements PropertyLoadSaver, and can therefore hold an arbitrary entity's contents. If a type implements the PropertyLoadSaver interface, it may also want to implement the KeyLoader interface. The KeyLoader interface exists to allow implementations of PropertyLoadSaver to also load an Entity's Key into the Go type. This type may be a struct pointer, but it does not have to be. The datastore package will call LoadKey when getting the entity's contents, after calling Load. Example code: To load a Key into a struct which does not implement the PropertyLoadSaver interface, see the "Key Field" section above. Queries retrieve entities based on their properties or key's ancestry. Running a query yields an iterator of results: either keys or (key, entity) pairs. Queries are re-usable and it is safe to call Query.Run from concurrent goroutines. Iterators are not safe for concurrent use. Queries are immutable, and are either created by calling NewQuery, or derived from an existing query by calling a method like Filter or Order that returns a new query value. A query is typically constructed by calling NewQuery followed by a chain of zero or more such methods. These methods are: Example code: Client.RunInTransaction runs a function in a transaction. Example code: Pass the ReadOnly option to RunInTransaction if your transaction is used only for Get, GetMulti or queries. Read-only transactions are more efficient. This package supports the Cloud Datastore emulator, which is useful for testing and development. Environment variables are used to indicate that datastore traffic should be directed to the emulator instead of the production Datastore service. To install and set up the emulator and its environment variables, see the documentation at https://cloud.google.com/datastore/docs/tools/datastore-emulator. To use the emulator with this library, you can set the DATASTORE_EMULATOR_HOST environment variable to the address at which your emulator is running. This will send requests to that address instead of to Cloud Datastore. You can then create and use a client as usual:

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/datastore#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.15.0 (published about 1 year ago)
• Last Synced: 2024-11-11T15:31:39.903Z (about 1 month ago)
• Versions: 22
• Dependent Packages: 809
• Dependent Repositories: 101,611
• Docker Downloads: 177,753,942
• Rankings:
  • Dependent repos count: 0.01%
  • Dependent packages count: 0.151%
  • Docker downloads count: 0.282%
  • Average: 0.475%
  • Forks count: 0.748%
  • Stargazers count: 1.185%

go: cloud.google.com/go/secretmanager

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/secretmanager#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.13.0 (published 8 months ago)
• Last Synced: 2024-11-11T16:32:08.950Z (about 1 month ago)
• Versions: 31
• Dependent Packages: 606
• Dependent Repositories: 6,647
• Docker Downloads: 117,047,664
• Rankings:
  • Dependent repos count: 0.093%
  • Dependent packages count: 0.2%
  • Docker downloads count: 0.258%
  • Average: 0.489%
  • Forks count: 0.728%
  • Stargazers count: 1.167%

go: cloud.google.com/go/logging

Package logging contains a Cloud Logging client suitable for writing logs. For reading logs, and working with sinks, metrics and monitored resources, see package cloud.google.com/go/logging/logadmin. This client uses Logging API v2. See https://cloud.google.com/logging/docs/api/v2/ for an introduction to the API. Use a Client to interact with the Cloud Logging API. For most use cases, you'll want to add log entries to a buffer to be periodically flushed (automatically and asynchronously) to the Cloud Logging service. You should call Client.Close before your program exits to flush any buffered log entries to the Cloud Logging service. For critical errors, you may want to send your log entries immediately. LogSync is slow and will block until the log entry has been sent, so it is not recommended for normal use. For cases when runtime environment supports out-of-process log ingestion, like logging agent, you can opt-in to write log entries to io.Writer instead of ingesting them to Cloud Logging service. Usually, you will use os.Stdout or os.Stderr as writers because Google Cloud logging agents are configured to capture logs from standard output. The entries will be Jsonified and wrote as one line strings following the structured logging format. See https://cloud.google.com/logging/docs/structured-logging#special-payload-fields for the format description. To instruct Logger to redirect log entries add RedirectAsJSON() LoggerOption`s. An entry payload can be a string, as in the examples above. It can also be any value that can be marshaled to a JSON object, like a map[string]interface{} or a struct: If you have a []byte of JSON, wrap it in json.RawMessage: If you have proto.Message and want to send it as a protobuf payload, marshal it to anypb.Any: You may want use a standard log.Logger in your program. An Entry may have one of a number of severity levels associated with it. You can view Cloud logs for projects at https://console.cloud.google.com/logs/viewer. Use the dropdown at the top left. When running from a Google Cloud Platform VM, select "GCE VM Instance". Otherwise, select "Google Project" and then the project ID. Logs for organizations, folders and billing accounts can be viewed on the command line with the "gcloud logging read" command. To group all the log entries written during a single HTTP request, create two Loggers, a "parent" and a "child," with different log IDs. Both should be in the same project, and have the same MonitoredResource type and labels. - A child entry's timestamp must be within the time interval covered by the parent request. (i.e., before the parent.Timestamp and after the parent.Timestamp - parent.HTTPRequest.Latency. This assumes the parent.Timestamp marks the end of the request.) - The trace field must be populated in all of the entries and match exactly. You should observe the child log entries grouped under the parent on the console. The parent entry will not inherit the severity of its children; you must update the parent severity yourself. You can automatically populate the Trace, SpanID, and TraceSampled fields of an Entry object by providing an http.Request object within the Entry's HTTPRequest field: When Entry with an http.Request is logged, its Trace, SpanID, and TraceSampled fields may be automatically populated as follows: Note that if Trace, SpanID, or TraceSampled are explicitly provided within an Entry object, then those values take precedence over values automatically extracted values.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/logging#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.9.0 (published about 1 year ago)
• Last Synced: 2024-11-11T10:03:04.730Z (about 1 month ago)
• Versions: 20
• Dependent Packages: 1,068
• Dependent Repositories: 4,552
• Docker Downloads: 3,297,164,495
• Rankings:
  • Dependent repos count: 0.124%
  • Dependent packages count: 0.139%
  • Docker downloads count: 0.323%
  • Average: 0.514%
  • Forks count: 0.78%
  • Stargazers count: 1.206%

go: cloud.google.com/go/firestore

Package firestore provides a client for reading and writing to a Cloud Firestore database. See https://cloud.google.com/firestore/docs for an introduction to Cloud Firestore and additional help on using the Firestore API. See https://godoc.org/cloud.google.com/go for authentication, timeouts, connection pooling and similar aspects of this package. Note: you can't use both Cloud Firestore and Cloud Datastore in the same project. To start working with this package, create a client with a project ID: In Firestore, documents are sets of key-value pairs, and collections are groups of documents. A Firestore database consists of a hierarchy of alternating collections and documents, referred to by slash-separated paths like "States/California/Cities/SanFrancisco". This client is built around references to collections and documents. CollectionRefs and DocumentRefs are lightweight values that refer to the corresponding database entities. Creating a ref does not involve any network traffic. Use DocumentRef.Get to read a document. The result is a DocumentSnapshot. Call its Data method to obtain the entire document contents as a map. You can also obtain a single field with DataAt, or extract the data into a struct with DataTo. With the type definition we can extract the document's data into a value of type State: Note that this client supports struct tags beginning with "firestore:" that work like the tags of the encoding/json package, letting you rename fields, ignore them, or omit their values when empty. To retrieve multiple documents from their references in a single call, use Client.GetAll. For writing individual documents, use the methods on DocumentReference. Create creates a new document. The first return value is a WriteResult, which contains the time at which the document was updated. Create fails if the document exists. Another method, Set, either replaces an existing document or creates a new one. To update some fields of an existing document, use Update. It takes a list of paths to update and their corresponding values. Use DocumentRef.Delete to delete a document. You can condition Deletes or Updates on when a document was last changed. Specify these preconditions as an option to a Delete or Update method. The check and the write happen atomically with a single RPC. Here we update a doc only if it hasn't changed since we read it. You could also do this with a transaction. To perform multiple writes at once, use a WriteBatch. Its methods chain for convenience. WriteBatch.Commit sends the collected writes to the server, where they happen atomically. You can use SQL to select documents from a collection. Begin with the collection, and build up a query using Select, Where and other methods of Query. Supported operators include '<', '<=', '>', '>=', '==', 'in', 'array-contains', and 'array-contains-any'. Call the Query's Documents method to get an iterator, and use it like the other Google Cloud Client iterators. To get all the documents in a collection, you can use the collection itself as a query. Firestore supports similarity search over embedding vectors. See Query.FindNearest for details. You can partition the documents of a Collection Group allowing for smaller subqueries. You can also Serialize/Deserialize queries making it possible to run/stream the queries elsewhere; another process or machine for instance. Use a transaction to execute reads and writes atomically. All reads must happen before any writes. Transaction creation, commit, rollback and retry are handled for you by the Client.RunTransaction method; just provide a function and use the read and write methods of the Transaction passed to it. This package supports the Cloud Firestore emulator, which is useful for testing and development. Environment variables are used to indicate that Firestore traffic should be directed to the emulator instead of the production Firestore service. To install and run the emulator and its environment variables, see the documentation at https://cloud.google.com/sdk/gcloud/reference/beta/emulators/firestore/. Once the emulator is running, set FIRESTORE_EMULATOR_HOST to the API endpoint.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/firestore#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.17.0 (published 3 months ago)
• Last Synced: 2024-11-15T04:01:52.272Z (about 1 month ago)
• Versions: 20
• Dependent Packages: 1,816
• Dependent Repositories: 57,670
• Docker Downloads: 22,994,383
• Rankings:
  • Dependent repos count: 0.021%
  • Dependent packages count: 0.097%
  • Average: 0.533%
  • Docker downloads count: 0.564%
  • Forks count: 0.78%
  • Stargazers count: 1.206%

go: cloud.google.com/go/profiler

Package profiler is a client for the Cloud Profiler service. Usage example: Calling Start will start a goroutine to collect profiles and upload to the profiler server, at the rhythm specified by the server. The caller must provide the service string in the config, and may provide other information as well. See Config for details. Profiler has CPU, heap and goroutine profiling enabled by default. Mutex profiling can be enabled in the config. Note that goroutine and mutex profiles are shown as "threads" and "contention" profiles in the profiler UI.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/profiler#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.4.0 (published about 1 year ago)
• Last Synced: 2024-11-11T03:31:37.790Z (about 1 month ago)
• Versions: 8
• Dependent Packages: 182
• Dependent Repositories: 482
• Docker Downloads: 798,435,736
• Rankings:
  • Docker downloads count: 0.133%
  • Dependent repos count: 0.32%
  • Dependent packages count: 0.362%
  • Average: 0.543%
  • Forks count: 0.731%
  • Stargazers count: 1.169%

go: google.golang.org/cloud

Package cloud is the root of the packages used to access Google Cloud Services. See https://godoc.org/cloud.google.com/go for a full list of sub-packages. All clients in sub-packages are configurable via client options. These options are described here: https://godoc.org/google.golang.org/api/option. All the clients in sub-packages support authentication via Google Application Default Credentials (see https://cloud.google.com/docs/authentication/production), or by providing a JSON key file for a Service Account. See the authentication examples in this package for details. By default, all requests in sub-packages will run indefinitely, retrying on transient errors when correctness allows. To set timeouts or arrange for cancellation, use contexts. See the examples for details. Do not attempt to control the initial connection (dialing) of a service by setting a timeout on the context passed to NewClient. Dialing is non-blocking, so timeouts would be ineffective and would only interfere with credential refreshing, which uses the same context. Connection pooling differs in clients based on their transport. Cloud clients either rely on HTTP or gRPC transports to communicate with Google Cloud. Cloud clients that use HTTP (bigquery, compute, storage, and translate) rely on the underlying HTTP transport to cache connections for later re-use. These are cached to the default http.MaxIdleConns and http.MaxIdleConnsPerHost settings in http.DefaultTransport. For gRPC clients (all others in this repo), connection pooling is configurable. Users of cloud client libraries may specify option.WithGRPCConnectionPool(n) as a client option to NewClient calls. This configures the underlying gRPC connections to be pooled and addressed in a round robin fashion. Minimal docker images like Alpine lack CA certificates. This causes RPCs to appear to hang, because gRPC retries indefinitely. See https://github.com/GoogleCloudPlatform/google-cloud-go/issues/928 for more information. To see gRPC logs, set the environment variable GRPC_GO_LOG_SEVERITY_LEVEL. See https://godoc.org/google.golang.org/grpc/grpclog for more information. For HTTP logging, set the GODEBUG environment variable to "http2debug=1" or "http2debug=2". Google Application Default Credentials is the recommended way to authorize and authenticate clients. For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials. To arrange for an RPC to be canceled, use context.WithCancel. You can use a file with credentials to authenticate and authorize, such as a JSON key file associated with a Google service account. Service Account keys can be created and downloaded from https://console.developers.google.com/permissions/serviceaccounts. This example uses the Datastore client, but the same steps apply to the other client libraries underneath this package. In some cases (for instance, you don't want to store secrets on disk), you can create credentials from in-memory JSON and use the WithCredentials option. The google package in this example is at golang.org/x/oauth2/google. This example uses the PubSub client, but the same steps apply to the other client libraries underneath this package. To set a timeout for an RPC, use context.WithTimeout.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/google.golang.org/cloud#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.113.0 (published 8 months ago)
• Last Synced: 2024-11-11T14:31:00.795Z (about 1 month ago)
• Versions: 153
• Dependent Packages: 82
• Dependent Repositories: 15,113
• Docker Downloads: 29,093,180
• Rankings:
  • Dependent repos count: 0.059%
  • Docker downloads count: 0.352%
  • Dependent packages count: 0.518%
  • Average: 0.572%
  • Forks count: 0.748%
  • Stargazers count: 1.185%

go: cloud.google.com/go/cloudtasks

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/cloudtasks#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.12.8 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:58.372Z (about 1 month ago)
• Versions: 32
• Dependent Packages: 97
• Dependent Repositories: 5,283
• Docker Downloads: 17,102,974
• Rankings:
  • Dependent repos count: 0.111%
  • Docker downloads count: 0.37%
  • Dependent packages count: 0.518%
  • Average: 0.579%
  • Forks count: 0.728%
  • Stargazers count: 1.167%

go: cloud.google.com/go/security

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/security#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.18.2 (published about 2 months ago)
• Last Synced: 2024-11-12T00:01:43.808Z (about 1 month ago)
• Versions: 38
• Dependent Packages: 83
• Dependent Repositories: 5,700
• Docker Downloads: 63,254,270
• Rankings:
  • Dependent repos count: 0.105%
  • Docker downloads count: 0.302%
  • Average: 0.586%
  • Dependent packages count: 0.618%
  • Forks count: 0.732%
  • Stargazers count: 1.174%

go: cloud.google.com/go/errorreporting

Package errorreporting is a Google Cloud Error Reporting library. Any provided stacktraces must match the format produced by https://golang.org/pkg/runtime/#Stack or as per https://cloud.google.com/error-reporting/reference/rest/v1beta1/projects.events/report#ReportedErrorEvent for language specific stacktrace formats. This package is still experimental and subject to change. See https://cloud.google.com/error-reporting/ for more information.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/errorreporting#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.3.0 (published about 2 years ago)
• Last Synced: 2024-11-11T05:14:51.242Z (about 1 month ago)
• Versions: 4
• Dependent Packages: 102
• Dependent Repositories: 3,191
• Docker Downloads: 17,042,705
• Rankings:
  • Dependent repos count: 0.141%
  • Dependent packages count: 0.509%
  • Docker downloads count: 0.584%
  • Average: 0.626%
  • Forks count: 0.728%
  • Stargazers count: 1.167%

go: cloud.google.com/go/containeranalysis

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/containeranalysis#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.11.6 (published 8 months ago)
• Last Synced: 2024-11-10T12:01:07.441Z (about 1 month ago)
• Versions: 30
• Dependent Packages: 55
• Dependent Repositories: 5,262
• Docker Downloads: 26,952,393
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.367%
  • Average: 0.629%
  • Forks count: 0.741%
  • Dependent packages count: 0.745%
  • Stargazers count: 1.178%

go: cloud.google.com/go/osconfig

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/osconfig#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.12.7 (published 8 months ago)
• Last Synced: 2024-11-10T10:00:55.858Z (about 1 month ago)
• Versions: 31
• Dependent Packages: 48
• Dependent Repositories: 5,220
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Average: 0.66%
  • Forks count: 0.736%
  • Dependent packages count: 0.907%
  • Stargazers count: 1.175%

go: cloud.google.com/go/grafeas

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/grafeas#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.3.12 (published about 2 months ago)
• Last Synced: 2024-11-12T00:01:13.738Z (about 1 month ago)
• Versions: 16
• Dependent Packages: 44
• Dependent Repositories: 5,077
• Docker Downloads: 9,900,948
• Rankings:
  • Dependent repos count: 0.118%
  • Docker downloads count: 0.616%
  • Average: 0.683%
  • Forks count: 0.728%
  • Dependent packages count: 0.787%
  • Stargazers count: 1.166%

go: cloud.google.com/go/artifactregistry

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/artifactregistry#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.14.9 (published 8 months ago)
• Last Synced: 2024-11-11T03:09:08.068Z (about 1 month ago)
• Versions: 39
• Dependent Packages: 39
• Dependent Repositories: 5,232
• Docker Downloads: 17,222,346
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.369%
  • Average: 0.685%
  • Forks count: 0.728%
  • Dependent packages count: 1.05%
  • Stargazers count: 1.167%

go: cloud.google.com/go/vision/v2

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/vision/v2#section-documentation
• Licenses: Apache-2.0
• Latest release: v2.8.2 (published 8 months ago)
• Last Synced: 2024-11-10T12:01:07.719Z (about 1 month ago)
• Versions: 26
• Dependent Packages: 32
• Dependent Repositories: 5,233
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Average: 0.686%
  • Forks count: 0.731%
  • Dependent packages count: 1.05%
  • Stargazers count: 1.169%

go: cloud.google.com/go/resourcemanager

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/resourcemanager#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.10.2 (published about 2 months ago)
• Last Synced: 2024-11-12T01:42:15.771Z (about 1 month ago)
• Versions: 29
• Dependent Packages: 53
• Dependent Repositories: 3,334
• Docker Downloads: 17,093,553
• Rankings:
  • Dependent repos count: 0.138%
  • Docker downloads count: 0.579%
  • Average: 0.718%
  • Forks count: 0.775%
  • Dependent packages count: 0.888%
  • Stargazers count: 1.208%

go: cloud.google.com/go/accesscontextmanager

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/accesscontextmanager#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.8.7 (published 8 months ago)
• Last Synced: 2024-11-11T11:35:30.499Z (about 1 month ago)
• Versions: 27
• Dependent Packages: 44
• Dependent Repositories: 3,325
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.14%
  • Docker downloads count: 0.58%
  • Average: 0.719%
  • Forks count: 0.728%
  • Dependent packages count: 0.981%
  • Stargazers count: 1.167%

go: cloud.google.com/go/domains

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/domains#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.9.7 (published 8 months ago)
• Last Synced: 2024-11-11T02:34:20.807Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 26
• Dependent Repositories: 5,225
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.113%
  • Docker downloads count: 0.37%
  • Average: 0.722%
  • Forks count: 0.735%
  • Stargazers count: 1.172%
  • Dependent packages count: 1.223%

go: cloud.google.com/go/language

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/language#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.12.5 (published 8 months ago)
• Last Synced: 2024-11-10T06:02:46.533Z (about 1 month ago)
• Versions: 31
• Dependent Packages: 26
• Dependent Repositories: 5,218
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.113%
  • Docker downloads count: 0.37%
  • Average: 0.723%
  • Forks count: 0.736%
  • Stargazers count: 1.175%
  • Dependent packages count: 1.223%

go: cloud.google.com/go/serviceusage

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/serviceusage#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.8.6 (published 8 months ago)
• Last Synced: 2024-11-10T05:01:00.933Z (about 1 month ago)
• Versions: 26
• Dependent Packages: 32
• Dependent Repositories: 3,191
• Docker Downloads: 729,034
• Rankings:
  • Dependent repos count: 0.141%
  • Docker downloads count: 0.579%
  • Forks count: 0.728%
  • Average: 0.728%
  • Dependent packages count: 1.024%
  • Stargazers count: 1.167%

go: cloud.google.com/go/securitycenter

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/securitycenter#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.30.0 (published 8 months ago)
• Last Synced: 2024-11-11T06:30:58.640Z (about 1 month ago)
• Versions: 48
• Dependent Packages: 30
• Dependent Repositories: 5,236
• Docker Downloads: 17,104,731
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.369%
  • Average: 0.73%
  • Forks count: 0.732%
  • Stargazers count: 1.174%
  • Dependent packages count: 1.261%

go: cloud.google.com/go/billing

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/billing#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.18.5 (published 8 months ago)
• Last Synced: 2024-11-11T10:03:02.000Z (about 1 month ago)
• Versions: 36
• Dependent Packages: 27
• Dependent Repositories: 5,229
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Average: 0.732%
  • Forks count: 0.739%
  • Stargazers count: 1.176%
  • Dependent packages count: 1.261%

go: cloud.google.com/go/servicedirectory

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/servicedirectory#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.11.6 (published 8 months ago)
• Last Synced: 2024-11-10T03:31:03.566Z (about 1 month ago)
• Versions: 30
• Dependent Packages: 23
• Dependent Repositories: 5,212
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.113%
  • Docker downloads count: 0.37%
  • Forks count: 0.736%
  • Average: 0.75%
  • Stargazers count: 1.175%
  • Dependent packages count: 1.358%

go: cloud.google.com/go/recommender

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/recommender#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.13.2 (published about 2 months ago)
• Last Synced: 2024-11-12T03:29:54.515Z (about 1 month ago)
• Versions: 30
• Dependent Packages: 21
• Dependent Repositories: 5,206
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.114%
  • Docker downloads count: 0.37%
  • Forks count: 0.775%
  • Average: 0.791%
  • Stargazers count: 1.208%
  • Dependent packages count: 1.488%

go: cloud.google.com/go/oslogin

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/oslogin#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.13.3 (published 8 months ago)
• Last Synced: 2024-10-29T11:35:12.185Z (about 2 months ago)
• Versions: 31
• Dependent Packages: 21
• Dependent Repositories: 5,205
• Docker Downloads: 17,142,677
• Rankings:
  • Dependent repos count: 0.113%
  • Docker downloads count: 0.37%
  • Forks count: 0.732%
  • Average: 0.791%
  • Stargazers count: 1.174%
  • Dependent packages count: 1.568%

go: cloud.google.com/go/workflows

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/workflows#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.12.6 (published 8 months ago)
• Last Synced: 2024-11-10T07:01:34.100Z (about 1 month ago)
• Versions: 31
• Dependent Packages: 21
• Dependent Repositories: 5,228
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Forks count: 0.714%
  • Average: 0.802%
  • Stargazers count: 1.156%
  • Dependent packages count: 1.659%

go: cloud.google.com/go/retail

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/retail#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.16.2 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:59.779Z (about 1 month ago)
• Versions: 36
• Dependent Packages: 21
• Dependent Repositories: 5,205
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.113%
  • Docker downloads count: 0.37%
  • Forks count: 0.732%
  • Average: 0.809%
  • Stargazers count: 1.174%
  • Dependent packages count: 1.659%

go: cloud.google.com/go/batch

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/batch#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.8.5 (published 8 months ago)
• Last Synced: 2024-11-11T18:02:42.376Z (about 1 month ago)
• Versions: 42
• Dependent Packages: 23
• Dependent Repositories: 3,327
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.14%
  • Docker downloads count: 0.58%
  • Forks count: 0.748%
  • Average: 0.815%
  • Stargazers count: 1.185%
  • Dependent packages count: 1.42%

go: cloud.google.com/go/video

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/video#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.20.6 (published 8 months ago)
• Last Synced: 2024-11-11T03:08:15.402Z (about 1 month ago)
• Versions: 40
• Dependent Packages: 21
• Dependent Repositories: 3,338
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.732%
  • Average: 0.823%
  • Stargazers count: 1.174%
  • Dependent packages count: 1.488%

go: cloud.google.com/go/videointelligence

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/videointelligence#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.12.2 (published about 2 months ago)
• Last Synced: 2024-11-12T01:40:22.401Z (about 1 month ago)
• Versions: 29
• Dependent Packages: 19
• Dependent Repositories: 5,214
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Forks count: 0.728%
  • Average: 0.829%
  • Stargazers count: 1.167%
  • Dependent packages count: 1.768%

go: cloud.google.com/go/binaryauthorization

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/binaryauthorization#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.9.2 (published about 2 months ago)
• Last Synced: 2024-11-12T02:51:42.713Z (about 1 month ago)
• Versions: 31
• Dependent Packages: 20
• Dependent Repositories: 5,225
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.113%
  • Docker downloads count: 0.37%
  • Forks count: 0.735%
  • Average: 0.832%
  • Stargazers count: 1.172%
  • Dependent packages count: 1.768%

go: cloud.google.com/go/accessapproval

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/accessapproval#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.8.2 (published about 2 months ago)
• Last Synced: 2024-11-12T01:38:40.795Z (about 1 month ago)
• Versions: 27
• Dependent Packages: 20
• Dependent Repositories: 3,311
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.14%
  • Docker downloads count: 0.58%
  • Forks count: 0.728%
  • Average: 0.836%
  • Stargazers count: 1.166%
  • Dependent packages count: 1.568%

go: cloud.google.com/go/dlp

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/dlp#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.13.0 (published 8 months ago)
• Last Synced: 2024-11-10T16:03:06.117Z (about 1 month ago)
• Versions: 35
• Dependent Packages: 21
• Dependent Repositories: 3,320
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.728%
  • Average: 0.836%
  • Stargazers count: 1.167%
  • Dependent packages count: 1.568%

go: cloud.google.com/go/dataproc

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/dataproc#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.12.0 (published almost 2 years ago)
• Last Synced: 2024-11-11T13:32:12.804Z (about 1 month ago)
• Versions: 13
• Dependent Packages: 19
• Dependent Repositories: 3,311
• Docker Downloads: 737,102
• Rankings:
  • Dependent repos count: 0.14%
  • Docker downloads count: 0.58%
  • Forks count: 0.775%
  • Average: 0.854%
  • Stargazers count: 1.208%
  • Dependent packages count: 1.568%

go: cloud.google.com/go/iot

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/iot#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.7.7 (published 8 months ago)
• Last Synced: 2024-11-11T15:30:46.832Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 19
• Dependent Repositories: 3,328
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.138%
  • Docker downloads count: 0.58%
  • Forks count: 0.732%
  • Average: 0.857%
  • Stargazers count: 1.174%
  • Dependent packages count: 1.659%

go: cloud.google.com/go/area120

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/area120#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.8.7 (published 8 months ago)
• Last Synced: 2024-11-11T08:02:02.110Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 16
• Dependent Repositories: 5,203
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Forks count: 0.714%
  • Average: 0.881%
  • Stargazers count: 1.156%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/networksecurity

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/networksecurity#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.9.7 (published 8 months ago)
• Last Synced: 2024-11-11T14:30:47.688Z (about 1 month ago)
• Versions: 26
• Dependent Packages: 16
• Dependent Repositories: 5,203
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Forks count: 0.714%
  • Average: 0.881%
  • Stargazers count: 1.156%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/dataqna

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/dataqna#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.8.7 (published 8 months ago)
• Last Synced: 2024-11-11T15:31:32.700Z (about 1 month ago)
• Versions: 24
• Dependent Packages: 16
• Dependent Repositories: 5,203
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Forks count: 0.728%
  • Average: 0.886%
  • Stargazers count: 1.167%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/webrisk

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/webrisk#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.9.7 (published 8 months ago)
• Last Synced: 2024-11-10T14:31:41.708Z (about 1 month ago)
• Versions: 27
• Dependent Packages: 16
• Dependent Repositories: 5,203
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Forks count: 0.732%
  • Average: 0.888%
  • Stargazers count: 1.174%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/edgecontainer

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/edgecontainer#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.2.1 (published 8 months ago)
• Last Synced: 2024-11-11T17:00:41.117Z (about 1 month ago)
• Versions: 24
• Dependent Packages: 16
• Dependent Repositories: 5,200
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.113%
  • Docker downloads count: 0.37%
  • Forks count: 0.741%
  • Average: 0.891%
  • Stargazers count: 1.177%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/servicecontrol

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/servicecontrol#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.13.2 (published 8 months ago)
• Last Synced: 2024-11-11T11:01:47.760Z (about 1 month ago)
• Versions: 30
• Dependent Packages: 15
• Dependent Repositories: 3,156
• Docker Downloads: 729,034
• Rankings:
  • Dependent repos count: 0.142%
  • Docker downloads count: 0.58%
  • Forks count: 0.728%
  • Average: 0.902%
  • Stargazers count: 1.167%
  • Dependent packages count: 1.892%

go: cloud.google.com/go/baremetalsolution

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/baremetalsolution#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.2.6 (published 8 months ago)
• Last Synced: 2024-11-11T13:31:19.394Z (about 1 month ago)
• Versions: 24
• Dependent Packages: 17
• Dependent Repositories: 3,324
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.138%
  • Docker downloads count: 0.58%
  • Forks count: 0.732%
  • Average: 0.903%
  • Stargazers count: 1.172%
  • Dependent packages count: 1.892%

go: cloud.google.com/go/phishingprotection

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/phishingprotection#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.8.7 (published 8 months ago)
• Last Synced: 2024-11-11T21:00:44.693Z (about 1 month ago)
• Versions: 24
• Dependent Packages: 16
• Dependent Repositories: 5,203
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Forks count: 0.775%
  • Average: 0.903%
  • Stargazers count: 1.208%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/gkeconnect

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/gkeconnect#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.11.2 (published about 2 months ago)
• Last Synced: 2024-11-11T23:31:56.754Z (about 1 month ago)
• Versions: 26
• Dependent Packages: 16
• Dependent Repositories: 5,203
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.112%
  • Docker downloads count: 0.37%
  • Forks count: 0.775%
  • Average: 0.903%
  • Stargazers count: 1.208%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/dataform

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/dataform#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.9.4 (published 8 months ago)
• Last Synced: 2024-11-11T15:02:16.341Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 16
• Dependent Repositories: 5,200
• Docker Downloads: 17,101,637
• Rankings:
  • Dependent repos count: 0.113%
  • Docker downloads count: 0.37%
  • Forks count: 0.775%
  • Average: 0.904%
  • Stargazers count: 1.208%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/vmmigration

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/vmmigration#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.7.7 (published 8 months ago)
• Last Synced: 2024-11-10T19:31:03.530Z (about 1 month ago)
• Versions: 27
• Dependent Packages: 17
• Dependent Repositories: 3,328
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.138%
  • Docker downloads count: 0.58%
  • Forks count: 0.775%
  • Average: 0.918%
  • Stargazers count: 1.208%
  • Dependent packages count: 1.892%

go: cloud.google.com/go/eventarc

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/eventarc#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.13.6 (published 8 months ago)
• Last Synced: 2024-11-11T11:34:25.117Z (about 1 month ago)
• Versions: 32
• Dependent Packages: 17
• Dependent Repositories: 3,307
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.775%
  • Average: 0.918%
  • Stargazers count: 1.208%
  • Dependent packages count: 1.892%

go: cloud.google.com/go/shell

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/shell#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.8.2 (published about 2 months ago)
• Last Synced: 2024-11-12T00:01:04.277Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 17
• Dependent Repositories: 3,308
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.775%
  • Average: 0.919%
  • Stargazers count: 1.208%
  • Dependent packages count: 1.892%

go: cloud.google.com/go/apigeeconnect

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/apigeeconnect#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.6.7 (published 8 months ago)
• Last Synced: 2024-11-11T04:02:49.656Z (about 1 month ago)
• Versions: 24
• Dependent Packages: 16
• Dependent Repositories: 3,308
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.728%
  • Average: 0.933%
  • Stargazers count: 1.167%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/contactcenterinsights

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/contactcenterinsights#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.15.1 (published about 2 months ago)
• Last Synced: 2024-11-12T00:02:27.856Z (about 1 month ago)
• Versions: 38
• Dependent Packages: 16
• Dependent Repositories: 3,307
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.731%
  • Average: 0.934%
  • Stargazers count: 1.169%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/gsuiteaddons

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/gsuiteaddons#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.6.7 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:57.305Z (about 1 month ago)
• Versions: 24
• Dependent Packages: 16
• Dependent Repositories: 3,308
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.732%
  • Average: 0.935%
  • Stargazers count: 1.174%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/filestore

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/filestore#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.9.2 (published about 2 months ago)
• Last Synced: 2024-11-12T03:30:16.893Z (about 1 month ago)
• Versions: 26
• Dependent Packages: 16
• Dependent Repositories: 3,307
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.735%
  • Average: 0.935%
  • Stargazers count: 1.172%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/storagetransfer

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/storagetransfer#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.10.6 (published 8 months ago)
• Last Synced: 2024-11-11T12:32:20.383Z (about 1 month ago)
• Versions: 28
• Dependent Packages: 16
• Dependent Repositories: 3,314
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.736%
  • Average: 0.936%
  • Stargazers count: 1.175%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/channel

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/channel#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.17.7 (published 8 months ago)
• Last Synced: 2024-11-11T15:31:54.412Z (about 1 month ago)
• Versions: 38
• Dependent Packages: 16
• Dependent Repositories: 3,308
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.739%
  • Average: 0.937%
  • Stargazers count: 1.176%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/networkmanagement

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/networkmanagement#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.13.2 (published 8 months ago)
• Last Synced: 2024-11-11T15:31:26.172Z (about 1 month ago)
• Versions: 31
• Dependent Packages: 16
• Dependent Repositories: 3,308
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.748%
  • Average: 0.941%
  • Stargazers count: 1.185%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/datafusion

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/datafusion#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.7.7 (published 8 months ago)
• Last Synced: 2024-11-11T14:31:10.975Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 16
• Dependent Repositories: 3,308
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.139%
  • Docker downloads count: 0.58%
  • Forks count: 0.775%
  • Average: 0.951%
  • Stargazers count: 1.208%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/dataplex

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/dataplex#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.16.0 (published 8 months ago)
• Last Synced: 2024-11-11T18:02:38.698Z (about 1 month ago)
• Versions: 43
• Dependent Packages: 16
• Dependent Repositories: 3,306
• Docker Downloads: 17,052,513
• Rankings:
  • Dependent repos count: 0.141%
  • Docker downloads count: 0.58%
  • Forks count: 0.775%
  • Average: 0.951%
  • Stargazers count: 1.208%
  • Dependent packages count: 2.052%

go: cloud.google.com/go/vmwareengine

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/vmwareengine#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.1.3 (published 8 months ago)
• Last Synced: 2024-11-11T11:34:04.772Z (about 1 month ago)
• Versions: 24
• Dependent Packages: 15
• Dependent Repositories: 2,909
• Docker Downloads: 17,041,474
• Rankings:
  • Dependent repos count: 0.149%
  • Docker downloads count: 0.584%
  • Forks count: 0.748%
  • Average: 0.982%
  • Stargazers count: 1.185%
  • Dependent packages count: 2.245%

go: cloud.google.com/go/recaptchaenterprise

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/recaptchaenterprise#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.3.1 (published over 2 years ago)
• Last Synced: 2024-11-11T03:07:31.731Z (about 1 month ago)
• Versions: 7
• Dependent Packages: 14
• Dependent Repositories: 5,048
• Docker Downloads: 48,637
• Rankings:
  • Dependent repos count: 0.113%
  • Forks count: 0.733%
  • Average: 1.025%
  • Stargazers count: 1.174%
  • Docker downloads count: 1.211%
  • Dependent packages count: 1.892%

go: cloud.google.com/go/apikeys

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/apikeys#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.1.7 (published 8 months ago)
• Last Synced: 2024-11-11T10:33:55.034Z (about 1 month ago)
• Versions: 24
• Dependent Packages: 15
• Dependent Repositories: 1,737
• Docker Downloads: 693,857
• Rankings:
  • Dependent repos count: 0.193%
  • Docker downloads count: 0.585%
  • Forks count: 0.764%
  • Average: 1.119%
  • Stargazers count: 1.212%
  • Dependent packages count: 2.842%

go: cloud.google.com/go/apigeeregistry

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/apigeeregistry#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.8.5 (published 8 months ago)
• Last Synced: 2024-11-11T18:02:34.057Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 12
• Dependent Repositories: 1,866
• Docker Downloads: 17,025,108
• Rankings:
  • Dependent repos count: 0.187%
  • Docker downloads count: 0.585%
  • Forks count: 0.752%
  • Stargazers count: 1.194%
  • Average: 1.22%
  • Dependent packages count: 3.38%

go: cloud.google.com/go/internal/aliasgen

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/internal/aliasgen#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.0.0-20240125231351-10c826099513 (published 11 months ago)
• Last Synced: 2024-11-11T11:01:32.534Z (about 1 month ago)
• Versions: 740
• Dependent Packages: 2
• Dependent Repositories: 9
• Rankings:
  • Forks count: 0.764%
  • Stargazers count: 1.212%
  • Dependent repos count: 1.734%
  • Average: 1.972%
  • Dependent packages count: 4.177%

go: cloud.google.com/go/internal/aliasfix

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/internal/aliasfix#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.0.0-20240125231351-10c826099513 (published 11 months ago)
• Last Synced: 2024-11-11T22:31:31.702Z (about 1 month ago)
• Versions: 875
• Dependent Packages: 2
• Dependent Repositories: 9
• Rankings:
  • Forks count: 0.764%
  • Stargazers count: 1.212%
  • Dependent repos count: 1.734%
  • Average: 1.972%
  • Dependent packages count: 4.177%

go: cloud.google.com/go/internal/gapicgen

Package gapicgen provides some helpers for gapicgen binaries.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/internal/gapicgen#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.0.0-20240125231351-10c826099513 (published 11 months ago)
• Last Synced: 2024-11-08T01:37:02.895Z (about 1 month ago)
• Versions: 397
• Dependent Packages: 1
• Dependent Repositories: 5
• Rankings:
  • Forks count: 0.779%
  • Stargazers count: 1.195%
  • Dependent repos count: 2.32%
  • Average: 2.361%
  • Dependent packages count: 5.149%

go: cloud.google.com/go/confidentialcomputing

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/confidentialcomputing#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.5.1 (published 8 months ago)
• Last Synced: 2024-11-10T13:18:35.164Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 0
• Dependent Repositories: 1
• Rankings:
  • Forks count: 0.72%
  • Stargazers count: 1.156%
  • Average: 4.036%
  • Dependent repos count: 4.706%
  • Dependent packages count: 9.561%

go: github.com/googleapis/google-cloud-go/logging

Package logging contains a Stackdriver Logging client suitable for writing logs. For reading logs, and working with sinks, metrics and monitored resources, see package cloud.google.com/go/logging/logadmin. This client uses Logging API v2. See https://cloud.google.com/logging/docs/api/v2/ for an introduction to the API. Note: This package is in beta. Some backwards-incompatible changes may occur. Use a Client to interact with the Stackdriver Logging API. For most use cases, you'll want to add log entries to a buffer to be periodically flushed (automatically and asynchronously) to the Stackdriver Logging service. You should call Client.Close before your program exits to flush any buffered log entries to the Stackdriver Logging service. For critical errors, you may want to send your log entries immediately. LogSync is slow and will block until the log entry has been sent, so it is not recommended for normal use. An entry payload can be a string, as in the examples above. It can also be any value that can be marshaled to a JSON object, like a map[string]interface{} or a struct: If you have a []byte of JSON, wrap it in json.RawMessage: You may want use a standard log.Logger in your program. An Entry may have one of a number of severity levels associated with it. You can view Stackdriver logs for projects at https://console.cloud.google.com/logs/viewer. Use the dropdown at the top left. When running from a Google Cloud Platform VM, select "GCE VM Instance". Otherwise, select "Google Project" and then the project ID. Logs for organizations, folders and billing accounts can be viewed on the command line with the "gcloud logging read" command. To group all the log entries written during a single HTTP request, create two Loggers, a "parent" and a "child," with different log IDs. Both should be in the same project, and have the same MonitoredResouce type and labels. - Parent entries must have HTTPRequest.Request populated. (Strictly speaking, only the URL is necessary.) - A child entry's timestamp must be within the time interval covered by the parent request (i.e., older than parent.Timestamp, and newer than parent.Timestamp - parent.HTTPRequest.Latency, assuming the parent timestamp marks the end of the request. - The trace field must be populated in all of the entries and match exactly. You should observe the child log entries grouped under the parent on the console. The parent entry will not inherit the severity of its children; you must update the parent severity yourself.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/logging#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.9.0 (published about 1 year ago)
• Last Synced: 2024-11-11T03:13:48.583Z (about 1 month ago)
• Versions: 20
• Dependent Packages: 0
• Dependent Repositories: 1
• Rankings:
  • Forks count: 0.78%
  • Stargazers count: 1.206%
  • Average: 4.063%
  • Dependent repos count: 4.706%
  • Dependent packages count: 9.561%

go: github.com/googleapis/google-cloud-go/bigtable

Package bigtable is an API to Google Cloud Bigtable. See https://cloud.google.com/bigtable/docs/ for general product documentation. See https://godoc.org/cloud.google.com/go for authentication, timeouts, connection pooling and similar aspects of this package. Use NewClient or NewAdminClient to create a client that can be used to access the data or admin APIs respectively. Both require credentials that have permission to access the Cloud Bigtable API. If your program is run on Google App Engine or Google Compute Engine, using the Application Default Credentials (https://developers.google.com/accounts/docs/application-default-credentials) is the simplest option. Those credentials will be used by default when NewClient or NewAdminClient are called. To use alternate credentials, pass them to NewClient or NewAdminClient using option.WithTokenSource. For instance, you can use service account credentials by visiting https://cloud.google.com/console/project/MYPROJECT/apiui/credential, creating a new OAuth "Client ID", storing the JSON key somewhere accessible, and writing Here, `google` means the golang.org/x/oauth2/google package and `option` means the google.golang.org/api/option package. The principal way to read from a Bigtable is to use the ReadRows method on *Table. A RowRange specifies a contiguous portion of a table. A Filter may be provided through RowFilter to limit or transform the data that is returned. To read a single row, use the ReadRow helper method. This API exposes two distinct forms of writing to a Bigtable: a Mutation and a ReadModifyWrite. The former expresses idempotent operations. The latter expresses non-idempotent operations and returns the new values of updated cells. These operations are performed by creating a Mutation or ReadModifyWrite (with NewMutation or NewReadModifyWrite), building up one or more operations on that, and then using the Apply or ApplyReadModifyWrite methods on a Table. For instance, to set a couple of cells in a table, To increment an encoded value in one cell, If a read or write operation encounters a transient error it will be retried until a successful response, an unretryable error or the context deadline is reached. Non-idempotent writes (where the timestamp is set to ServerTime) will not be retried. In the case of ReadRows, retried calls will not re-scan rows that have already been processed.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/bigtable#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.23.0 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:25.943Z (about 1 month ago)
• Versions: 37
• Dependent Packages: 0
• Dependent Repositories: 1
• Rankings:
  • Forks count: 0.78%
  • Stargazers count: 1.206%
  • Average: 4.063%
  • Dependent repos count: 4.706%
  • Dependent packages count: 9.561%

go: github.com/googleapis/google-cloud-go/compute/metadata

Package metadata provides access to Google Compute Engine (GCE) metadata and API service accounts. This package is a wrapper around the GCE metadata service, as documented at https://developers.google.com/compute/docs/metadata.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/compute/metadata#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.2.3 (published about 2 years ago)
• Last Synced: 2024-11-11T03:13:25.035Z (about 1 month ago)
• Versions: 11
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.535%
  • Stargazers count: 0.743%
  • Average: 4.406%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/functions

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/functions#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.16.2 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:21.546Z (about 1 month ago)
• Versions: 35
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.536%
  • Stargazers count: 0.745%
  • Average: 4.407%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/profiler

Package profiler is a client for the Stackdriver Profiler service. This package is still experimental and subject to change. Usage example: Calling Start will start a goroutine to collect profiles and upload to the profiler server, at the rhythm specified by the server. The caller must provide the service string in the config, and may provide other information as well. See Config for details. Profiler has CPU, heap and goroutine profiling enabled by default. Mutex profiling can be enabled in the config. Note that goroutine and mutex profiles are shown as "threads" and "contention" profiles in the profiler UI.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/profiler#section-documentation
• Licenses: Apache-2.0
• Latest release: v0.4.0 (published about 1 year ago)
• Last Synced: 2024-11-11T03:13:49.110Z (about 1 month ago)
• Versions: 8
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.536%
  • Stargazers count: 0.745%
  • Average: 4.407%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/iam

Package iam supports the resource-specific operations of Google Cloud IAM (Identity and Access Management) for the Google Cloud Libraries. See https://cloud.google.com/iam for more about IAM. Users of the Google Cloud Libraries will typically not use this package directly. Instead they will begin with some resource that supports IAM, like a pubsub topic, and call its IAM method to get a Handle for that resource.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/iam#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.1.8 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:27.840Z (about 1 month ago)
• Versions: 33
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.536%
  • Stargazers count: 0.745%
  • Average: 4.407%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/monitoring

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/monitoring#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.19.0 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:21.555Z (about 1 month ago)
• Versions: 40
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.536%
  • Stargazers count: 0.745%
  • Average: 4.407%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/firestore

Package firestore provides a client for reading and writing to a Cloud Firestore database. See https://cloud.google.com/firestore/docs for an introduction to Cloud Firestore and additional help on using the Firestore API. See https://godoc.org/cloud.google.com/go for authentication, timeouts, connection pooling and similar aspects of this package. Note: you can't use both Cloud Firestore and Cloud Datastore in the same project. To start working with this package, create a client with a project ID: In Firestore, documents are sets of key-value pairs, and collections are groups of documents. A Firestore database consists of a hierarchy of alternating collections and documents, referred to by slash-separated paths like "States/California/Cities/SanFrancisco". This client is built around references to collections and documents. CollectionRefs and DocumentRefs are lightweight values that refer to the corresponding database entities. Creating a ref does not involve any network traffic. Use DocumentRef.Get to read a document. The result is a DocumentSnapshot. Call its Data method to obtain the entire document contents as a map. You can also obtain a single field with DataAt, or extract the data into a struct with DataTo. With the type definition we can extract the document's data into a value of type State: Note that this client supports struct tags beginning with "firestore:" that work like the tags of the encoding/json package, letting you rename fields, ignore them, or omit their values when empty. To retrieve multiple documents from their references in a single call, use Client.GetAll. For writing individual documents, use the methods on DocumentReference. Create creates a new document. The first return value is a WriteResult, which contains the time at which the document was updated. Create fails if the document exists. Another method, Set, either replaces an existing document or creates a new one. To update some fields of an existing document, use Update. It takes a list of paths to update and their corresponding values. Use DocumentRef.Delete to delete a document. You can condition Deletes or Updates on when a document was last changed. Specify these preconditions as an option to a Delete or Update method. The check and the write happen atomically with a single RPC. Here we update a doc only if it hasn't changed since we read it. You could also do this with a transaction. To perform multiple writes at once, use a WriteBatch. Its methods chain for convenience. WriteBatch.Commit sends the collected writes to the server, where they happen atomically. You can use SQL to select documents from a collection. Begin with the collection, and build up a query using Select, Where and other methods of Query. Supported operators include `<`, `<=`, `>`, `>=`, `==`, and 'array-contains'. Call the Query's Documents method to get an iterator, and use it like the other Google Cloud Client iterators. To get all the documents in a collection, you can use the collection itself as a query. Use a transaction to execute reads and writes atomically. All reads must happen before any writes. Transaction creation, commit, rollback and retry are handled for you by the Client.RunTransaction method; just provide a function and use the read and write methods of the Transaction passed to it.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/firestore#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.15.0 (published 10 months ago)
• Last Synced: 2024-11-11T03:13:29.309Z (about 1 month ago)
• Versions: 20
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.536%
  • Stargazers count: 0.745%
  • Average: 4.407%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/cloudtasks

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/cloudtasks#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.12.8 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:45.310Z (about 1 month ago)
• Versions: 32
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.509%
  • Stargazers count: 0.999%
  • Average: 4.463%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/language

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/language#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.12.5 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:18.034Z (about 1 month ago)
• Versions: 31
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/oslogin

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/oslogin#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.13.3 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:24.122Z (about 1 month ago)
• Versions: 31
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/notebooks

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/notebooks#section-documentation
• Licenses: apache-2.0
• Latest release: v1.11.5 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:23.066Z (about 1 month ago)
• Versions: 32
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/maps

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/maps#section-documentation
• Licenses: apache-2.0
• Latest release: v1.7.3 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:17.604Z (about 1 month ago)
• Versions: 40
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/orchestration

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/orchestration#section-documentation
• Licenses: apache-2.0
• Latest release: v1.9.2 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:18.864Z (about 1 month ago)
• Versions: 28
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/speech

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/speech#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.23.1 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:24.392Z (about 1 month ago)
• Versions: 43
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/recommendationengine

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/recommendationengine#section-documentation
• Licenses: apache-2.0
• Latest release: v0.8.7 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:18.665Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/datafusion

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/datafusion#section-documentation
• Licenses: apache-2.0
• Latest release: v1.7.7 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:25.187Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/eventarc

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/eventarc#section-documentation
• Licenses: apache-2.0
• Latest release: v1.13.6 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:15.665Z (about 1 month ago)
• Versions: 32
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/area120

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/area120#section-documentation
• Licenses: apache-2.0
• Latest release: v0.8.7 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:22.615Z (about 1 month ago)
• Versions: 25
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/metastore

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/metastore#section-documentation
• Licenses: apache-2.0
• Latest release: v1.13.6 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:20.902Z (about 1 month ago)
• Versions: 33
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/orgpolicy

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/orgpolicy#section-documentation
• Licenses: apache-2.0
• Latest release: v1.12.3 (published 8 months ago)
• Last Synced: 2024-10-29T11:35:30.036Z (about 2 months ago)
• Versions: 29
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/workflows

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/workflows#section-documentation
• Licenses: apache-2.0
• Latest release: v1.12.6 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:23.837Z (about 1 month ago)
• Versions: 31
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/contactcenterinsights

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/contactcenterinsights#section-documentation
• Licenses: apache-2.0
• Latest release: v1.13.2 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:48.297Z (about 1 month ago)
• Versions: 38
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/scheduler

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/scheduler#section-documentation
• Licenses: Apache-2.0
• Latest release: v1.10.8 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:19.309Z (about 1 month ago)
• Versions: 29
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/recaptchaenterprise/v2

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/recaptchaenterprise/v2#section-documentation
• Licenses: apache-2.0
• Latest release: v2.13.0 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:21.556Z (about 1 month ago)
• Versions: 36
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.707%
  • Stargazers count: 1.034%
  • Average: 4.522%
  • Dependent packages count: 6.999%
  • Dependent repos count: 9.346%

go: cloud.google.com/go/security/privateca/apiv1beta1

Package privateca is an auto-generated package for the Certificate Authority API. For information about setting deadlines, reusing contexts, and more please visit https://pkg.go.dev/cloud.google.com/go. To get started with this package, create a client. The client will use your default application credentials. Clients should be reused instead of created as needed. The methods of Client are safe for concurrent use by multiple goroutines. The returned client must be Closed when it is done being used. The following is an example of making an API call with the newly created client. The ctx passed to NewCertificateAuthorityClient is used for authentication requests and for creating the underlying connection, but is not used for subsequent calls. Individual methods on the client use the ctx given to them. To close the open connection, use the Close() method.

• Homepage: https://github.com/googleapis/google-cloud-go
• Documentation: https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1beta1#section-documentation
• Licenses: Apache-2.0
• Latest release: (published 7 months ago)
• Last Synced: 2024-11-11T03:13:14.529Z (about 1 month ago)
• Versions: 0
• Dependent Packages: 3
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 2.464%
  • Average: 5.149%
  • Dependent repos count: 7.834%

go: github.com/googleapis/google-cloud-go/auth/oauth2adapt

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/auth/oauth2adapt#section-documentation
• Licenses: apache-2.0
• Latest release: v0.2.2 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:22.692Z (about 1 month ago)
• Versions: 7
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Forks count: 0.716%
  • Stargazers count: 1.154%
  • Average: 5.371%
  • Dependent packages count: 8.907%
  • Dependent repos count: 10.707%

go: github.com/googleapis/google-cloud-go/parallelstore

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/parallelstore#section-documentation
• Licenses: apache-2.0
• Latest release: v0.2.0 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:24.155Z (about 1 month ago)
• Versions: 15
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 6.998%
  • Average: 7.446%
  • Dependent repos count: 7.893%

go: github.com/googleapis/google-cloud-go/cloudquotas

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/cloudquotas#section-documentation
• Licenses: apache-2.0
• Latest release: v0.2.1 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:18.314Z (about 1 month ago)
• Versions: 14
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 6.998%
  • Average: 7.446%
  • Dependent repos count: 7.893%

go: github.com/googleapis/google-cloud-go/resourcemanager

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/resourcemanager#section-documentation
• Licenses: apache-2.0
• Latest release: v1.9.7 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:17.721Z (about 1 month ago)
• Versions: 29
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 6.999%
  • Average: 8.173%
  • Dependent repos count: 9.346%

go: github.com/googleapis/google-cloud-go/security

• Homepage:
• Documentation: https://pkg.go.dev/github.com/googleapis/google-cloud-go/security#section-documentation
• Licenses: apache-2.0
• Latest release: v1.16.1 (published 8 months ago)
• Last Synced: 2024-11-11T03:13:52.996Z (about 1 month ago)
• Versions: 38
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 6.999%
  • Average: 8.173%
  • Dependent repos count: 9.346%