Developing Applications on Google Cloud

A Google Cloud Function is a type of serverless computing service provided by Google Cloud Platform (GCP). It allows you to write small, single-purpose functions in popular programming languages such as JavaScript, Python, and Go. These functions are triggered by events, such as HTTP requests, changes in data stored in databases or storage buckets, or messages from messaging services.

In this guide,we'll show you how to create a Google Cloud Function using both the Google Cloud Console and the gcloud command-line tool.

1. Go to Google Cloud Console: Open your web browser and navigate to the Google Cloud Console at https://console.cloud.google.com/.
   
   
2. Select or Create a Project: Choose an existing project from the dropdown menu at the top of the page, or create a new project by clicking on the "Select a project" dropdown and then clicking on "New Project". Follow the prompts to create a new project.
   
   
   

   ---

   
   
   
3. Navigate to Cloud Functions: In the left sidebar, click on "Cloud Functions" under the "Compute" section.
   
   
4. Create a New Cloud Function: Click on the "Create Function" button.
   
   
5. Configure the Cloud Function:
   

1. Name and Environment: Pick a clear name for your function and opt for the 2nd generation environment for enhanced features.
   
   Choose a Region: Select a region nearest to your users for optimal performance.
   
   
2. Triggers: Decide how your function will be activated:
   
   • HTTPS: Respond to HTTP requests, with the option to allow unauthenticated invocations for external API calls.
   
   • Pub/Sub: React to messages published to a Pub/Sub topic.
   
   • Firestore: Execute in response to changes in Firestore documents.
   
   • Storage: Run when files are uploaded to a Cloud Storage bucket.
   
   If you select the HTTPS trigger, you can enable unauthenticated invocations for external API calls without needing authentication
   
   
3. After configuring triggers, you'll adjust your function's settings:

• Runtime: Set memory allocation and CPU for your function, along with a timeout.

• Auto-scaling: Specify the minimum and maximum number of instances for optimal performance.

• Runtime Environment Variables: Optionally create runtime environment variables, skipping if you've set them at build time.

• Build Environment Variables: In the build section, set up environment variables for build time.

For Connections & Security and Image Repo settings, you can keep the default options or adjust them as needed.

After completing the settings, click "Next" to proceed to the next page, where you'll find the code section.

In the "Code" section, you'll start by selecting the runtime, which determines the programming language you'll use—options include Node.js, Java 11, Java 17, Python, and more.

Next, in the "Source Code" field, you have three options:

• Inline Editor: Use the built-in code editor to write your code directly .
  
  

• Zip Upload: Upload a zip folder containing your code from your local machine.
  
  

• Zip from Cloud Storage: Select a zip folder stored in your cloud storage.
  
  

Choose the option that suits you best for uploading or writing your code.

After inserting your code, simply hit the "Deploy" button. To access your function, use the triggers you set up earlier. For instance, if you selected the HTTPS option during function creation, you'll find a URL provided below. Simply send a request to that URL to trigger your function.

Example:

Here's a simple guide to creating and deploying a Cloud Function using the gcloud CLI:

• Open your command line interface.
  
  
• Check your gcloud configuration by running:
  

1gcloud config list 

Ensure the correct account and project ID are set for where you want to create the function.

• Navigate to the directory containing your Cloud Functions code.
  
  
• Run the following command to deploy your function
  

1gcloud functions deploy function-test-name \ 
2--gen2 \
3--runtime=nodejs20 \
4--region=us-central1 \
5--source=. \
6--entry-point=mongodump \
7--trigger-http \
8--memory=2GiB \
9--cpu=1 \
10--set-env-vars=PORT=8080 \
11--set-build-env-vars=PORT=8080,TEST_!=testValue \
12--max-instances=2

Here's a breakdown of the options used:

• --gen2: Specifies using the 2nd generation runtime environment.
  
  
• --runtime=nodejs20: Sets the runtime to Node.js 20.
  
  
• --region=us-central1: Specifies the region where the function will be deployed.
  
  
• --source=.: Deploys the function from the current directory.
  
  
• --entry-point=mongodump: Specifies the function's entry point.
  
  
• --trigger-http: Configures the function to be triggered by HTTP requests.
  
  
• --memory=2GiB: Allocates 2 GiB of memory to the function.
  
  
• --set-env-vars=PORT=8080: Sets a runtime environment variable PORT to 8080.
  
  
• --cpu=1: Assigns 1 virtual CPU to the function.
  
  
• --set-build-env-vars=PORT=8080,TEST_1=testValue: Sets build time environment
  
  
• --set-env-vars=PORT=8080: Sets a runtime environment variable PORT to 8080.
  
  
• --max-instances=2: Sets maximum instances.
  
  
  Feel free to adjust the options based on your specific requirements.
  
  

This command will deploy your Cloud Function with the specified configurations.

After running the command, if you've selected the trigger as HTTP, it will ask whether to allow unauthenticated invocations of the new function. Simply type 'Y' for yes or 'N' for no.

Once the deployment is successful, you'll receive a URL to trigger your function.

If you haven't allowed or unable to get url, you can check the details of your function using the command:

1gcloud functions describe function-test-name --region=us-central1

Replace "function-test-name" with the actual name of your function.

To delete your function, use this command:

1gcloud functions delete google-function-test --gen2 --region=asia-south1

After successfully deleting the function, you'll receive a confirmation message.

For a complete list of commands and options, click here.

Google Cloud Scheduler is a fully managed cron job scheduler on Google Cloud Platform. It handles all your routine jobs automatically, making sure they run smoothly and fit into your workflow without any confusion.

1. Go to Google Cloud Console: Open your web browser and navigate to the Google Cloud Console at https://console.cloud.google.com/.
   
   
2. Navigate to Cloud Scheduler: In the left sidebar, click on "Cloud Scheduler" under the "Compute" section.
   
   
   

3. Create a New Cloud Scheduler: Click on the "CREATE JOB" button.
   
   
4. Configure the Cloud Scheduler Job:
   
   

• Create Scheduler Job:
  
  

1. Enter a name for your job.
   
2. Keep the default region as "us-central."
   
3. Optionally, add a description.
   
4. Set the frequency using a cron expression.
   
5. Choose the timezone for your schedule.
   
6. Click "Continue" to save details.
   
   

• Configure Execution:
  
  

1. Unfold the "Configure the execution" section.
   
2. Choose the target type: HTTP, Pub/Sub, or Workflows via HTTP.
   
   

• If selecting HTTP:

1. Provide the request URL.
2. Specify the HTTP method.
3. Add any necessary headers.
4. Optionally, include a request body.
5. Configure authentication if needed.
   
   

• If selecting pub/sub:

1. select cloud pub/sub topic.
2. provide message body for that topic in message body field.
3. add an attribute also if needed
   
   

• Click "Continue" to save your execution settings.
  
  
• Optional Settings:
  
  

1. Unfold the "Configure Optional Settings" section.
2. Adjust retry configurations if desired:
   

• Set maximum retry attempts.
• Define maximum retry duration.
• Specify minimum and maximum backoff durations.
  
  
• Click "CREATE" to create your scheduler job.
  

After successful creation of job , it's enabled by default, meaning it's ready to run according to the schedule you've defined.

Here's the command line for creating a Cloud Scheduler job using the gcloud command-line tool, along with an example:

1gcloud scheduler jobs create http my-job --schedule="0 * * * *" --uri=https://example.com \
2--location=us-central1 \
3--description="Hourly job" \
4--headers="Content-Type=application/json" \
5--http-method=GET \
6--max-retry-attempts=3 \
7--time-zone=America/Los_Angeles

(for http scheduler job)

1gcloud scheduler jobs create pubsub my-job --schedule="0 * * * *" \
2--location=us-central1 \
3--topic=pubsub_topic \
4--message-body="Test" \
5--max-retry-attempts=3 \
6--time-zone=America/Los_Angeles

(for pub/sub job scheduler job ,replace pubsub_topic to actual topic name of cloud pub/sub)

After creating a job, you can check its status, pause, resume, or delete it using these commands:

• List Jobs:
  

1gcloud scheduler jobs list --location=us-central1

• Describe Job:

1gcloud scheduler jobs describe my-job --location=us-central1

• Pause Jobs:
  

1gcloud scheduler jobs pause my-job --location=us-central1

You'll receive a confirmation message if the job is successfully paused.( "Job has been paused.")

• Resume Job:

1gcloud scheduler jobs resume my-job --location=us-central1

You'll receive a confirmation message if the job is successfully paused.( "Job has been resumed.")

• Delete Job:

1gcloud scheduler jobs delete my-job --location=us-central1

It will ask for confirmation to delete,after confirmation gets confirmation message.("Deleted job [my-job]")

For a complete list of commands and options, click here.

Cloud storage allows users to store and access data over the internet, providing flexibility and scalability for personal and business needs. Use cases include backup solutions for data security and collaboration platforms for seamless team workflows.

• Click "Create bucket," then follow the prompts
  
  

1. Name your bucket: Choose a unique name for your bucket that follows the naming guidelines provided.
   
   

2. Choose where to store your data: Select a location for your bucket. Options include:
   
   

Multi-region: Provides redundancy across multiple regions.

Dual-region: Offers redundancy across two specific regions.

Region: Stores data in a specific region.

3. Choose a storage class for your data:
   
   

• Select a storage class based on your data's access frequency and durability requirements. Options may include Standard, Nearline, Coldline, and Archive.
  
  

4. Choose how to control access to objects:
   
   

• Specify access controls for both the bucket and objects inside it.
  
  
• Optionally, uncheck the "Enforce public access prevention on this bucket" checkbox if you want to allow public access.
  
  

5. Choose how to protect object data:
   
   

• Configure data protection settings, including deletion and restoration policies.
  
  
• Select an encryption method for object data, such as Google-managed keys, customer-managed keys, or customer-supplied keys.

Here's, using the gcloud command-line tool to create a Google Cloud Storage bucket with specific configurations

1. Create Bucket :
   
   

1gcloud storage buckets create gs://my-bucket-test-00011 \
2  --default-storage-class=standard \
3  --location=us \
4  --public-access-prevention \
5  --uniform-bucket-level-access \
6  --soft-delete-duration=7d

• gcloud storage buckets create gs://my-bucket-test-00011 : This part of the command instructs gcloud to create a bucket named "my-bucket-test-00011" in Google Cloud Storage.
  
  
• --default-storage-class=standard : Sets the default storage class for the bucket to "standard".
  
  
• --location=us : Specifies the location of the bucket as the United States. Change "us" to your preferred region if needed.
  
  
• --public-access-prevention : Enables public access prevention on the bucket, restricting public access by default.
  
  
• --no-public-access-prevention : Disables public access prevention on the bucket.
  
  
• --uniform-bucket-level-access : Enables uniform bucket-level access to all objects, which simplifies access control by using only IAM policies.
  
  
• --soft-delete-duration=7d : Sets the soft-delete retention period to 7 days, meaning deleted objects will be retained for 7 days before permanent deletion.

After creating your bucket, if you want it to be accessible to the public on the internet, run the following command:

1gcloud storage buckets add-iam-policy-binding gs://my-bucket-test-00011 --member=allUsers --role=roles/storage.objectViewer

This command grants public access to view objects in your bucket.

2. Describe Bucket:
   
   

1gcloud storage buckets describe gs://my-bucket-test-00011

3. Delete Bucket :
   

1gcloud storage buckets delete gs://my-bucket-test-00011

4. List Buckets :
   

1gcloud storage buckets list

For a complete list of commands and options, click here.

1. Create Service Account Credentials:

• In the Google Cloud Console, navigate to IAM & Admin > Service Accounts.
• Select service account which you want to use for accessing bucket from code
• Click on keys section
• Inside ADD KEY choose Create new key
• Choose JSON as the key type and click "Create". This will download a JSON file containing your service account credentials. Keep this file secure.
  

2. Install Required Packages:
   

• Create a new Node.js project or navigate to your existing project.
• Install the @google-cloud/storage package:
  

1npm install @google-cloud/storage

3. Set Up Authentication:

• Place the JSON file containing your service account credentials in a secure location within your project directory.

4. Use Cloud Storage in Your Node.js Application:

• Initialize the Cloud Storage client in your Node.js application:
  

1const { Storage } = require('@google-cloud/storage');
2
3// Creates a client
4  const storage = new Storage({
5    keyFilename: "key.json",
6  });

• Use the upload() method on the bucket object to upload the file.
  

1 const options = {
2    destination: "test/new-image.png",  // desired destination directory and filename in the bucket , optional
3    metadata: {													// optional
4      metadata: {
5        event: "Fall trip to the zoo",
6      },
7    },
8  };
9  // Lists files in the bucket
10  const files = await storage
11    .bucket("my-test-bucket-00011")
12    .upload(
13      "filename",
14      options,
15      (error, file) => {
16        if (file) {
17          console.log("file ", file);
18        }
19      }
20    );

Provide the filename, upload options, and handle any errors or success messages accordingly.

• Use the getFiles() method to get files/objects of bucket .

1const files = await storage.bucket("my-test-bucket-00011").getFiles();

• Use the file() method to get specific file/object from bucket .

1const file = await storage.bucket("my-test-bucket-00011").file('filename');

• Use the delete() method to get specific file/object from bucket .

1const file = await storage.bucket("my-test-bucket-00011").file('filename').delete();

Google Cloud Run is a serverless platform that lets you run your applications in containers without managing servers. It automatically scales your app based on traffic and you only pay for the resources used when your app is running. This makes it easy to deploy and manage applications efficiently. This makes it easy to deploy and manage applications efficiently, especially for backend services and APIs.

Steps to Deploy an Application on Google Cloud Run

1. Containerize Application (Using Docker ):

• Create a Dockerfile to define container in root folder.

1FROM node:18-alpine
2
3# Create app directory
4WORKDIR /usr/src/app
5
6# A wildcard is used to ensure both package.json AND package-lock.json are copied
7COPY package*.json ./
8
9# Install app dependencies
10RUN npm install
11
12# Bundle app source
13COPY . .
14
15# Creates a "dist" folder with the production build
16RUN npm run build
17
18# Start the server using the production build 
19CMD [ "npm","run", "start:prod" ]

• Build your Docker image using command .

1docker build -t gcr.io/google-cloud-project-id/test-application .

• gcr.io: The domain for Google Container Registry.
  
  
• google-cloud-project-id: Google Cloud project ID. This uniquely identifies your project within Google Cloud Platform.
  
  
• test-application: The name of your Docker image.

2. Push the Image to Container Registry:

• Use Google Container Registry or Artifact Registry ( for now we are using Container Registry).

• Push your Docker image using command.

1docker push gcr.io/google-cloud-project-id/test-application

if it gets any authentication error then run

1gcloud auth configure-docker

or

1gcloud auth configure-docker gcr.io

4. Select Deployment Option:

• By default, "Deploy one revision from an existing container image" is selected.

• (Alternatively, you can select "Continuously deploy from a repository" to set up continuous deployment using Cloud Build. This involves selecting a repository provider like GitHub, configuring the repository, and setting up the build configuration, but we'll focus on deploying from a container image.)

5. Configure Your Service

• In the "Container image URL" tab, click on "Select."

• A sidebar will open with two options: "Artifact Registry" and "Container Registry."
  
  

Artifact Registry: Create a repository and store your image there if using this option.

Container Registry: Select this option since we have already pushed our image here.

• Choose your Docker image from the Container Registry.

6. Provide Service Details:

• Enter a name for your service.

• Select the region where you want your service to run.

7. Configure Authentication:

In the "Authentication" section, you have two options:

• Require authentication (default): Only authenticated users can access the service.
• Allow unauthenticated invocations: The service will be accessible publicly.

If your service needs to be accessible publicly (e.g., an API that you want to call from a browser or Postman), select "Allow unauthenticated invocations."

Note: To enable "Allow unauthenticated invocations," you need admin access or run.services.setIamPolicy permission in the IAM policy.

8. Configure CPU Allocation and Pricing:

In the "CPU allocation and pricing" section, you have two options:

• CPU is only allocated during request processing (default)

• Always allocated

For now, select the default setting: "CPU is only allocated during request processing."

9. Configure Service Auto-Scaling:

• In the "Service auto-scaling" section, set the minimum number of instances to "0."

10. Configure Ingress Control:

In the "Ingress control" section, you have two options:

• Internal: Allow traffic from your project, shared VPC, and VPC service controls perimeter.

• All (default): Allow direct access to your service from the Internet.

Select the default setting: "All."

Unfold the Container(s), volumes, networking, security section: Navigate to the section in your deployment interface where you can manage containers, volumes, networking, and security settings.

11. Inside Container tab, specify container port:

• Look for the "Container Port" field within the Container tab. Here, enter the port number that your container will listen on for incoming connections.

Under Container tab, find SETTINGS, VARIABLES AND SECRETS, VOLUME MOUNTS: These are separate sections where you can configure various aspects related to your container.

12. In SETTINGS section, find container command and container arguments:

• If you need to specify commands or arguments for the entry point of your container, enter them in the "Container Command" and "Container Arguments" fields. Leave these blank if defined in the container image.

13. Resources section:

• Here, you can adjust the CPU and memory resources allocated to your container. Use default settings if they satisfy.

14. Health checks section:

• Optionally, configure health checks if your application requires .

15. Variables and secrets section:

• Add environment variables needed for your container. Use the "Reference a secret" button to include variables from secret manager if required.

16. Volume mounts section:

• Mount volumes that you create in the Volumes section. Alternatively, navigate directly to the Volumes tab using the "Go To Volumes Tab" button.

17. Adding another container:

• If needed, add additional containers by clicking the "ADD CONTAINER" button and repeat the configuration steps above.

18. Requests section:

• Set parameters like Request timeout and Maximum concurrent requests per instance as needed. Defaults are used if unspecified.

19. Execution environment:

• Specify the execution environment necessary for your container to run properly.

20. Revision auto-scaling:

• Define the minimum and maximum number of container instances required. For demonstration purposes, set it to 3 instances.

21. Startup CPU boost:

• Check this box to allocate extra CPU resources temporarily while starting the container.

22. Cloud SQL Connection section:

• If using Cloud SQL, configure connections in this section to integrate with your application.

23. VOLUMES section:

• Add volumes by clicking the "ADD VOLUME" button to manage persistent data storage through in memory, secrets or cloud storages for your containers .

24. NETWORKING section:

• Configure networking options such as HTTP/2 end-to-end support, session affinity for WebSocket connections, and VPC connectivity for outbound traffic.

25. SECURITY section:

• Select the deployment account and choose an encryption key if required, ensuring secure deployment practices.

Once configurations are complete, click "Done" to save your settings and proceed with deployment.

Go through all the configured values to ensure correctness. Click the "Create" button to finalize the deployment.

After deployment, you will receive the URL for accessing your application.

• Describe the Container Image

First, you need to get the fully qualified digest of the Docker image you have pushed. You can do this by describing the container image using the gcloud command.

1gcloud container images describe gcr.io/google-cloud-project-id/test-application

• Find the Digest

In the output of the above command, look for the digest which will be in the format:

gcr.io/google-cloud-project-id/test-application@sha256:<sha_value>

• Deploy the Image to Google Cloud Run

Use the fully qualified digest you obtained in Step 2 to deploy the image to Google Cloud Run. Replace <sha_value> with the actual SHA value from the previous step.

1gcloud run deploy test-application \
2--image=gcr.io/google-cloud-project-id/test-application@sha256:f42563567(random sha value) \
3--allow-unauthenticated \
4--port=8080 \
5--max-instances=3 \
6--region=us-central1 \
7--set-env-vars='TEST_ENV=test value'
8

• Output

After executing the deploy command, you will get the URL of your deployed service in the output. This URL can be used to access your deployed application.

Step-by-step guide to delete a service .

• Delete the Service

To delete a specific service, use the gcloud run services delete command. You need to specify the service name and the region.

1gcloud run services delete test-application --region us-central1

• Confirm Deletion

After running the command, you will be prompted with:

1Do you want to continue (Y/n)?

Type Y and hit Enter to confirm the deletion.

• Output

Once the service is successfully deleted, you will see the following message in the output:

1Deleted service [test-application]

For a complete list of commands and options, click here.

Using Google Cloud Platform (GCP) for application development provides great scalability, flexibility, and tools to make your workflow easier. Take advantage of GCP's powerful features to create and deliver excellent user experiences.

There's a lot to cover in this topic, so if you have any questions or need more help, feel free to reach out. Happy coding!