Google Cloud Platform Blog: April 2017

Better VM Rightsizing Recommendations with the Stackdriver Agent

Thursday, April 27, 2017

By Pawel Siarkiewicz, Product ManagerVM Rightsizing Recommendations

Recommendations without visibility to how the accessed RAM is used

Stackdriver Agent

Stackdriver Agent-based recommendations with a look through to the used RAM

install the agent

Manage your gRPC APIs with Google Cloud Endpoints

Wednesday, April 26, 2017

By Dan Ciruli, Product Manager—essential component for microservicesCloud Pub/Sub releaseCloud BigtableCloud Pub/SubCloud Vision APICloud DatastoreCloud Speech APICloud Spanner API

import "google/protobuf/empty.proto"; // A simple Bookstore API. // // The API manages shelves and books resources. Shelves contain books. service Bookstore { // Returns a list of all shelves in the bookstore. rpc CreateShelf(CreateShelfRequest) returns (Shelf) {} // Returns a specific bookstore shelf. rpc GetShelf(GetShelfRequest) returns (Shelf) {} } // A shelf resource. message Shelf { // A unique shelf id. int64 id = 1; // A theme of the shelf (fiction, poetry, etc). string theme = 2; } // Request message for CreateShelf method. message CreateShelfRequest { // The shelf resource to create. Shelf shelf = 1; } // Request message for GetShelf method. message GetShelfRequest { // The ID of the shelf resource to retrieve. int64 shelf = 1; }type: google.api.Service config_version: 3 name: bookstore.endpoints..cloud.goog title: Bookstore gRPC API apis: - name: endpoints.examples.bookstore.Bookstore Http: rules: # 'CreateShelf' can be called using the POST HTTP verb and the '/shelves' URL # path. The posted HTTP body is the JSON respresentation of the 'shelf' field # of 'CreateShelfRequest' protobuf message. # # Client example: # curl -d '{"theme":"Music"}' http://DOMAIN_NAME/v1/shelves # - selector: endpoints.examples.bookstore.Bookstore.CreateShelf post: /v1/shelves body: shelf # # 'GetShelf' is available via the GET HTTP verb and '/shelves/{shelf}' URL # path, where {shelf} is the value of the 'shelf' field of 'GetShelfRequest' # protobuf message. # # Client example - returns the first shelf: # curl http://DOMAIN_NAME/v1/shelves/1 # - selector: endpoints.examples.bookstore.Bookstore.GetShelf get: /v1/shelves/{shelf}# # Request authentication. # authentication: providers: - id: google_service_account # Replace SERVICE-ACCOUNT-ID with your service account's email address. issuer: SERVICE-ACCOUNT-ID jwks_uri: https://www.googleapis.com/robot/v1/metadata/x509/SERVICE-ACCOUNT-ID rules: # This auth rule will apply to all methods. - selector: "*" requirements: - provider_id: google_service_accounthttps://cloud.google.com/endpoints/docs/transcodingPythonGoJavaNode.jsGoogle Group

NAB 2017: Rendering updates to GCP

Tuesday, April 25, 2017

By Todd Prives, Product ManagerGoogle Cloud PlatformZync Render

Added rendering support for the popular Arnold Render for Cinema 4D. Arnold is a renderer used in countless feature film, advertising, VR and television projects and support in Cinema 4D allows Zync users to scale to tens of thousands of cores on demand when rendering a scene with Arnold.

We’ve also cut pricing for many Zync applications (Maya, Cinema 4D & Houdini) by up to 31%.

Securing Rendering Workloads Solution

Going multi-cloud with Google Cloud Endpoints and AWS Lambda

Monday, April 24, 2017

By Sowmya Kannan, Technical Curriculum Developer, Google Cloud PlatformVisionCloud Video IntelligenceData Loss PreventionGoogle Cloud PlatformGoogle Cloud EndpointsAWS Lambda

Cloud EndpointsOpenAPI specificationApp EngineGoogle Container EngineCompute Enginedownload the complete source code for this sample from GitHub Setting up Cloud EndpointsApp Engine flexible environment

Use the GCP Console to create a new GCP project and an App Engine application.

When prompted, select the region where you want to run your App Engine application located and then enable billing.

Note the ID of your project, because you'll need it later.

Activate Google Cloud Shell

Retrieving source codeGoogle Cloud Shell

Clone the GitHub repository with source code for the example.

Change directory to blogs/endpointslambda/aeflex-endpoints/

Launch the code editor to view source code.

Implementing application code @app.route('/processmessage', methods=['POST']) def process(): """Process messages with information about S3 objects""" message = request.get_json().get('inputMessage', '') # add other processing as needed # for example, add event to PubSub or # download object using presigned URL, save in Cloud Storage, invoke ML APIs return jsonify({'In app code for endpoint, received message': message}) Configuring and deploying the Cloud Endpoints APISwagger object host: "echo-api.endpoints.aeflex-endpoints.cloud.goog"inputMessage# This section configures the processmessage endpoint. "/processmessage": post: description: "Process the given message." operationId: "processmessage" produces: - "application/json" responses: 200: description: "Return a success response" schema: $ref: "#/definitions/successMessage" parameters: - description: "Message to process" in: body name: inputMessage required: true schema: $ref: "#/definitions/inputMessage" security: - api_key: [] definitions: successMessage: properties: message: type: string inputMessage: # This section contains information about the S3 bucket and object to be processed. properties: Bucket: type: string ObjectKey: type: string ContentType: type: string ContentLength: type: integer ETag: type: string PresignedUrl: type: string gcloud service-management deploy openapi.yamlService Configuration [2017-03-05r2] uploaded for service "echo-api.endpoints.aeflex-endpoints.cloud.goog"endpoints_api_service: # The following values are to be replaced by information from the output of # 'gcloud service-management deploy openapi.yaml' command. name: echo-api.endpoints.aeflex-endpoints.cloud.goog config_id: 2017-03-05r2 gcloud app deploy

In the GCP Console, on the Products & services menu, click API Manager > Credentials.

Click Create Credentials > API key. Note the API key.

Setting up the AWS Lambda functionblogs/endpointslambda/lambdafunctioninline.py. Creating the S3 Bucket for your files Creating an IAM Role

In the IAM Management Console, click Roles in the navigation pane.

Create a new role called LambdaExecRole.

Select AWS Lambda Role Type, and then select the following policies:

AWSLambdaExecute: This policy gives the Lambda function Put and Get access to S3 and full access to CloudWatch Logs.
AmazonSQSFullAccess: This policy gives the Lambda function permissions to send messages to the dead-letter queue (DLQ).

Review the settings and create the role.

Creating an SQS queue

In the SQS Management Console, create an SQS queue called IntegrationDLQ that will act as the dead-letter queue for your Lambda function. AWS Lambda automatically retries failed executions for asynchronous invocations. In addition, you can configure Lambda to forward payloads that were not processed to a dead-letter queue.

Creating a Lambda function in the AWS Console

In the Select blueprint page, use the s3-get-object-python blueprint.

In the Configure triggers page, specify the following:

Bucket: images-bucket-rawdata
Event-type: Object-Created (All)

Enable the trigger.

In the Configure Function page, specify the following:

Name: CallEndpoint
Runtime: Python 2.7
Code entry type: Edit code inline
Environment variable key: ENDPOINT_API_KEY
Environment variable: . Note: For production environments, consider securing the API key using encryption helpers in AWS.
Handler: lambda_function.lambda_handler
Role: Choose an existing role
Existing role: LambdaExecRole (that you created earlier)
In Advanced settings, DLQ resource: IntegrationDLQ

In the inline code editor for the Lambda function, replace the original code with the following code. The Lambda function retrieves the bucket and object information from the event, retrieves object metadata, generates a pre-signed url for the object, and finally invokes the Cloud Endpoints API.

from __future__ import print_function

import boto3
import json
import os
import urllib
import urllib2


print('Loading function')

s3 = boto3.client('s3')
endpoint_api_key = os.environ['ENDPOINT_API_KEY']
endpoint_url = "https://aeflex-endpoints.appspot.com/processmessage"

def lambda_handler(event, context):

    # Get the object information from the event
    bucket = event['Records'][0]['s3']['bucket']['name']
    object_key = urllib.unquote_plus(event['Records'][0]['s3']['object']['key'].encode('utf8'))
    try:
        # Retrieve object metadata
        response = s3.head_object(Bucket=bucket, Key=object_key)
        # Generate pre-signed URL for object
        presigned_url = s3.generate_presigned_url('get_object', Params = {'Bucket': bucket, 'Key': object_key}, ExpiresIn = 3600)
        data = {"inputMessage": {
                    "Bucket": bucket,
                    "ObjectKey": object_key,
                    "ContentType": response['ContentType'],
                    "ContentLength": response['ContentLength'],
                    "ETag": response['ETag'],
                    "PresignedUrl": presigned_url
            }
        }

        headers = {"Content-Type": "application/json",
                    "x-api-key": endpoint_api_key
        }
        # Invoke Cloud Endpoints API
        request = urllib2.Request(endpoint_url, data = json.dumps(data), headers = headers)
        response = urllib2.urlopen(request)
        
        print('Response text: {} \nResponse status: {}'.format(response.read(), response.getcode()))

        return response.getcode()
    except Exception as e:
        print(e)
        print('Error integrating lambda function with endpoint for the object {} in bucket {}'.format(object_key, bucket))
        raise e

Review the Lambda function configuration and create the function.

Testing the integration

In the AWS S3 Management Console, upload a file to images-bucket-rawdata.

In the Lambda Management Console, navigate to the CallEndpoint function, and view the Monitoring tab. The CloudWatch graphs show that the function was invoked successfully.

Click View Logs in CloudWatch and view the details for the function’s log stream. The log shows that the Lambda function received a success response code (200) from the API as well as details about the S3 event that the API received from the Lambda function.

Solutions guide: How to secure rendering workloads on GCP

Friday, April 21, 2017

By Adrian Graham, Cloud Solutions Architect
Securing Rendering WorkloadsGoogle Cloud Platformsecuritycore complianceMPAA best practicestrial

Getting started with Cloud Identity-Aware Proxy

Thursday, April 20, 2017

By Matthew Sachs, Technical Lead ManagerCloud Identity-Aware ProxyGoogle Cloud Platformour previous post about Cloud IAP How does Cloud IAP work?App EngineCloud Load Balancing HTTP(S)App Engine appGoogle Compute Engine backend serviceauth serverCloud Identity & Access Management Authenticating with OpenID ConnectOpenID ConnectGCP_IAAP_AUTH_TOKEN1Authorization: bearerconfigure an OAuth2 client manuallyGoogle’s OpenID Connect flowhandles the OAuth redirectcompletes the OpenID Connect flowprotect against Cross-Site Request Forgery attacksnonceGCP_IAAP_XSRF_NONCEhe OAuth flow state parameter Robot paradeauthenticating from a service account

Create a JWT with the following claims:

aud: https://www.googleapis.com/oauth2/v4/token
exp: Some time in the future.
iat: The current time.
iss: Your service account’s email address.
target_audience: Either the base URL (protocol, domain and optional port; no path) or OAuth2 client ID for your Cloud IAP-protected application. (This controls the aud claim in the resulting OpenID Connect token. Cloud IAP validates this claim to prevent a token intended for use in one application from being used with another application.)

If you have a service account private key, use it to sign the JWT. If you only have an access token, use the App Engine standard environment App Identity API or Cloud IAM signBlob API to sign it.

POST it to the URL in the aud claim by Using OAuth 2.0 for Server to Server Applications.

Authorization with Cloud IAMfolderorganizationroles/iap.httpsResourceAccessorOwnerEditor Propagating identity

For applications using the Google App Engine standard environment, Cloud IAP supports the App Engine Users API. Existing code using this API typically works with no modifications, and Cloud IAP even uses the same user IDs as Users API.

Cloud IAP sends the user’s email address and ID in two HTTP headers.

can’t2insidemisconfigured your firewall rulesthird HTTP headerJSON Web TokenIAP quickstartssecurity and identity
1 Yes, there’s an extra A.
2 The Users API, on the other hand, is safe. Cloud IAP uses a protected internal channel to set the identity information consumed by this API.

220,000 cores and counting: MIT math professor breaks record for largest ever Compute Engine job

Thursday, April 20, 2017

By Alex Barrett, GCP Blog Editor & Michael Basilyan, Product Manager, Compute Engine
Editor's Note: This post was updated on June 12, 2017.Compute EnginePreemptible VMsAndrew V. SutherlandSato-Tate Conjectureconjecture of Birch and Swinnerton-Dyergenus17hyperelliptic curvesL-functionsinteresting Sato-Tate distributionsLMFDB

Finding suitable genus 3 curves “is like searching for a needle in a fifteen-dimensional haystack,” Sutherland said. “Sometimes I like to describe my work as building telescopes for mathematicians.”

It also requires a lot of compute cycles: For each curve that's examined, its discriminant must be computed; the discriminant of a curve serves as an upper bound on the complexity of computing its L-function. This task is trivial in genus 1, but in genus 3 may involve evaluating a 50 million term polynomial in 15 variables. Each curve that's a candidate for inclusion in the LMFDB must also have many other of its arithmetic and geometric invariants computed, including an approximation of its L-function and Sato-Tate distribution, as well as information about any symmetries it may possess. The results can be quite large, and some of this information is stored as Cloud Storage nearline objects. Researchers can browse summaries of the results on the curve’s home page in the LMFDB, or download more detailed information to their own computer for further examination. The LMFDB provides an online interface to some 400 gigabytes of metadata housed in a MongoDB database that also runs on Compute Engine.

Sutherland began using Compute Engine in 2015. For his first-ever job, he fired up 2,250 32-core instances and completed about 60 CPU-years of computation in a single afternoon.

Before settling on Compute Engine, Sutherland ran jobs on his own 64-core machine, which could take months, or wrangled for compute time on one of MIT’s clusters. But getting the number of cores he needed often raised eyebrows, and he was limited by the software configurations he could use. By running on Compute Engine, Sutherland can install exactly the operating system, libraries and applications he needs, and thanks to root access, he can update his environment at will.

Sutherland considered running his jobs on AWS before choosing Google but was dissuaded by its Spot Instances model, which forces you to name your price up front, with prices that can vary significantly by region and fluctuate over time. A colleague encouraged him to try Compute Engine Preemptible VMs. These are full-featured instances that are priced up to 80% less than regular equivalents, but can be interrupted by Compute Engine. That was fine with Sutherland. His computations are embarrassingly parallel ——Google Cloud Regions
To coordinate the instances working on a job, Sutherland uses a combination of Cloud Storage and Datastore. He used the python client API to implement a simple ticketing system in Datastore that assigns tasks to instances. Instances periodically checkpoint their progress on their local disks from which they can recover if preempted, and they store their final output data in a Cloud Storage bucket, where it may undergo further post-processing once the job has finished.

All told, having access to the scale and flexibility of Compute Engine has freed Sutherland up to think much bigger with his research. For his next run, he hopes to expand his search to non-hyperelliptic curves of genus 3, breaking his own record with a 400,000-core cluster. “It changes your whole outlook on research when you can ask a question and get an answer in hours rather than months,” he said. “You ask different questions.”Update: June 12, 2017⸺

This is further proof that GCP should be your choice for HPC jobs in the realms of mathematics, drug discovery, rendering, seismic exploration ⸺ you name it. If you have big questions that need big compute, our free trial gives you $300 in credits to get started.

Distributed tracing for Go

Wednesday, April 19, 2017

By Jaana Burcu Dogan, EngineerGoogle Cloud Platform The case for distributed tracing

Dapper

Instrument and profile application latency in a large system.

Track all RPCs within the lifecycle of a user request and see integration issues that are only visible in production.

Figure out performance improvements that can be applied to our systems. Many bottlenecks are not obvious before the collection of tracing data.

Tracing conceptsspans

Working with Stackdriver TraceStackdriver TraceCloud Console—cloud.google.com/go/tracefile bugs and feature requestsget application default credentialsimport "cloud.google.com/go/trace"traceClient, err = trace.NewClient(ctx, "project-id") if err != nil { log.Fatal(err) }func fetchUsers() ([]*User, error) { span := traceClient.NewSpan("/users") defer span.Finish() // Create the outgoing request, a GET to the users endpoint. req, _ := http.NewRequest("GET", "https://userservice.corp/users", nil) // Create a new child span to identify the outgoing request, // and attach tracing information to the request. rspan := span.NewRemoteChild(req) defer rspan.Finish() res, err := http.DefaultClient.Do(req) if err != nil { return nil, err } // Read the body, unmarshal, and return a slice of users. // ... }func usersHandler(w http.ResponseWriter, r *http.Request) { span := traceClient.SpanFromRequest(r) defer span.Finish() req, _ := http.NewRequest("GET", "https://meta.service/info", nil) child := span.NewRemoteChild(req) defer child.Finish() // Make the request… }HTTPClientHTTPHandlervar tc *trace.Client // initiate the client req, _ := http.NewRequest("GET", "https://userservice.corp/users", nil) res, err := tc.NewHTTPClient(nil).Do(req) if err != nil { // TODO: Handle error. }handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { span := trace.FromContext(r.Context()) // TODO: Use the span. }) http.Handle("/foo", tc.HTTPHandler(handler))gRPC Go clients and servers—Stackdriver Trace docs
Future work

Guest post: Supercharging container pipelines with Codefresh and Google Cloud

Wednesday, April 19, 2017

By Raziel Tabib, CEO and Co-founder, Codefresh[Editor’s note: Today we hear from Codefresh, which makes a Docker-native continuous integration/continuous delivery (CI/CD) platform. Read on to learn how Codefresh’s recent integrations with Kubernetes and Google Container Registry will make it easier for you to build, test and deploy your cloud-native applications to Google Cloud, including Container Engine and Kubernetes.]Container RegistryGoogle Container Engine

Advantages of an embedded registry

Image quality control is higher since it’s built right into the test flow

Build-assist images (for example, those used with Java and other compiled languages) stay nicely organized in the dev space

Codefresh extends the images with valuable metadata (e.g., test results, commit info, build SHA, logs, issue id, etc.), creating a sandbox-like registry for developers

Build speed is faster since the embedded registry is "closer" to the build machines

join the beta One-click deploy to Kubernetesdeploying to Kubernetes

deploy-to-kubernetes-staging: image: codefreshio/kubernetes-deployer:master tag: latest working-directory: ${{initial-clone}} commands: - /deploy/bin/deploy.sh ./root environment: - ENVIRONMENT=${{ENVIRONMENT}} - KUBERNETES_USER=${{KUBERNETES_USER}} - KUBERNETES_PASSWORD=${{KUBERNETES_PASSWORD}} - KUBERNETES_SERVER=${{KUBERNETES_SERVER}} - DOCKER_IMAGE_TAG=${{CF_REVISION}} Migrating to Google Cloud’s Container Engine— About Codefresh, CI/CD for Dockerhttps://codefresh.io/embedded registry beta

Cloud Speech API is now generally available

Tuesday, April 18, 2017

By Dan Aharon, Product ManagerlaunchedCloud Speech APIpre-trained machine-learning models

Improved transcription accuracy for long-form audio

Faster processing, typically 3x faster than the prior version for batch scenarios

Expanded file format support, now including WAV, Opus and Speex

InteractiveTel “Google Cloud Speech API performs highly accurate speech-to-text transcription in near-real-time. The higher accuracy rates mean we can help dealers get the most out of phone interactions with their customers and increase sales.” — Gary Graves, CTO and Co-Founder, InterActiveTelhere

Guest post: Using Terraform to manage Google Cloud Platform infrastructure as code

Tuesday, April 18, 2017

By Seth Vargo, Director of Technical Advocacy, HashiCorp
TerraformHashiCorpGoogle Cloud Platformresource "google_compute_instance" "blog" { name = "default" machine_type = "n1-standard-1" zone = "us-central1-a" disk { image = "debian-cloud/debian-8" } disk { type = "local-ssd" scratch = true } network_interface { network = "default" } }$ terraform plan + google_compute_instance.default can_ip_forward: "false" create_timeout: "4" disk.#: "2" disk.0.auto_delete: "true" disk.0.disk_encryption_key_sha256: "" disk.0.image: "debian-cloud/debian-8" disk.1.auto_delete: "true" disk.1.disk_encryption_key_sha256: "" disk.1.scratch: "true" disk.1.type: "local-ssd" machine_type: "n1-standard-1" metadata_fingerprint: "" name: "default" self_link: "" tags_fingerprint: "" zone: "us-central1-a" $ terraform apply google_compute_instance.default: Creating... can_ip_forward: "" => "false" create_timeout: "" => "4" disk.#: "" => "2" disk.0.auto_delete: "" => "true" disk.0.disk_encryption_key_sha256: "" => "" disk.0.image: "" => "debian-cloud/debian-8" disk.1.auto_delete: "" => "true" disk.1.disk_encryption_key_sha256: "" => "" disk.1.scratch: "" => "true" disk.1.type: "" => "local-ssd" machine_type: "" => "n1-standard-1" metadata_fingerprint: "" => "" name: "" => "default" network_interface.#: "" => "1" network_interface.0.address: "" => "" network_interface.0.name: "" => "" network_interface.0.network: "" => "default" self_link: "" => "" tags_fingerprint: "" => "" zone: "" => "us-central1-a" google_compute_instance.default: Still creating... (10s elapsed) google_compute_instance.default: Still creating... (20s elapsed) google_compute_instance.default: Creation complete (ID: default) Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

(click to enlarge)

Google Cloud Nextprojects and foldersbillingresource "google_project" "blog" { name = "blog-demo" project_id = "blog-demo-491834" billing_account = "${var.billing_id}" org_id = "${var.org_id}" } resource "google_project_services" "blog" { project = "${google_project.blog.project_id}" services = [ "iam.googleapis.com", "cloudresourcemanager.googleapis.com", "cloudapis.googleapis.com", "compute-component.googleapis.com", ] } resource "google_compute_instance" "blog" { # ... project = "${google_project.blog.project_id}" # <-- ...="" code="" new="" option="">$ terraform apply google_compute_instance.default: Refreshing state... (ID: default) google_project.my_project: Creating... name: "" => "blog-demo" number: "" => "" org_id: "" => "1012963984278" policy_data: "" => "" policy_etag: "" => "" project_id: "" => "blog-demo-491834" skip_delete: "" => "" google_project.my_project: Still creating... (10s elapsed) google_project.my_project: Creation complete (ID: blog-demo-491835) Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

(click to enlarge)

Use CasesEphemeral environmentsRapid project stampingOn-demand continuous integrationTerraform websitecode on GitHub

Cloud Identity-Aware Proxy: Protect application access on the cloud

Monday, April 17, 2017

By Ameet Jani, Product ManagerCloud Identity-Aware ProxyGoogle Cloud Platform— How Cloud IAP workssimple access policiesBeyondCorpSecurity Key Management Cloud IAP pricing

Automating project creation with Google Cloud Deployment Manager

Thursday, April 13, 2017

By Chris Crall, Product Manager
Google Cloud PlatformGoogle Cloud Deployment ManagerCompute EngineContainer EngineCloud SQLBigQueryCloud Storage

Project Creation - create the new project with the name you provide

Billing - set the billing account for the new project

Permissions - set the IAM policy on the project

Service Accounts - optionally create service accounts for the applications or services to run in this project

APIs - turn on compatible Google APIs that the services or applications in a project may need

Getting started

The project creation samples are available in the Deployment Manager github repo under the project_creation directory. Or clone the whole DM github repo:

git clone
https://github.com/GoogleCloudPlatform/deploymentmanager-samples.git

Then copy the templates under the examples/v2/project_creation directory.

Follow the steps in the Readme in the project_creation directory. The readme includes detailed instructions, but there is one point to emphasize. You should create a new project using the Cloud Console that will be used as your “Project Creation” project. The service account under which Deployment Manager runs needs powerful IAM permissions to create projects and manage billing accounts, hence the recommendation to create this special project and use it only for creation of other projects.

Customize your deployments.

At a minimum, you'll need to change the config.yaml file to add the name of the project you want to create, your billing account, the APIs you want, the IAM permissions you choose to use and the APIs to enable.
Advanced customization — you can do as little or as much as you want here. Let’s assume that your company typically has three types of projects: production service projects, test service projects and developer sandbox projects. These projects require vastly different IAM permissions, different types of service accounts and may also need different APIs. You could add a new top level template with a parameter for “project-type”. That parameter takes a string as input (such as “prodservice”, “testservice” or “developer”) and uses that value to customize the project for your needs. Alternatively, you can make three copies of the .yaml file — one for each project type with the correct settings for your three project types.

Create your project.
From the directory where you stored your templates, use the command line interface to run Deployment Manager:

gcloud deployment-manager deployments create 
<newproject_deployment> --config config.yaml --project <Project 
Creation project>

Where <newproject_deployment> is the name you want to give the deployment. This is not the new project name, that comes from the value in the config.yaml file. But you may want to use the same name for the deployment, or something similar so you know how they match up once you’ve stamped out a few hundred projects.

dep-mgr-feedback@google.com

The state of Ruby on Google Cloud Platform

Tuesday, April 11, 2017

By Aja Hammerly, Developer AdvocateGoogle Cloud Next '17App Engine to RubyistspaperclipMRIPostgres on Cloud SQLGoogle Cloud Platformhttp://cloud.google.com/rubyNew gems on tapStackdriver LoggingGoogle Cloud DatastoreGoogle Cloud StorageGoogle BigQueryGoogle Cloud Translation APIGoogle Cloud Vision APIrequire "google/cloud/logging" logging = Google::Cloud::Logging.new logger = logging.logger "my_app_log", resource, env: :production logger.info "Job started" logger.info { "Job started" } logger.debug?RailsConfRailsConf 2017What's my app really doing in productionGoogle Cloud <3 RubySyntax isn't everything: NLP for RubyistsGoogle Cloud Natural Language API

Google Cloud Storage introduces Cloud Pub/Sub notifications

Monday, April 10, 2017

By Brandon Yarbrough, Software Engineer, Google Cloud StorageGoogle Cloud Storage Cloud Pub/Sub SupportGoogle Cloud Pub/Subgetting started guideenabled the Cloud Pub/Sub API$> gsutil notification create -f json -t your-topic gs://your-bucketin this example Python app Cloud FunctionsGoogle Cloud Functions

Cloud Functionsget started with Google Cloud Functions$> gcloud beta functions deploy helloWorld --stage-bucket cloud-functions --trigger-bucket your-bucket