Google Cloud on Experiment, Fail, Learn, Repeat

Using Alloy and Grafana for extracting metrics and pushing to dashboard

Wed, 20 Aug 2025 00:00:00 +0000

I need to deploy a metrics exporter to check for nodes on instances and push it into a grafana metrics dashboard

We can demonstrate this with 2 instances

Deploy alloy to collect Node Metrics
#

We would first install alloy of the instance we would want to monitor. Here are the reference for it: https://grafana.com/docs/alloy/latest/set-up/install/linux/

Container Signing Experimentation

Thu, 31 Jul 2025 00:00:00 +0000

One of the major things that I was researching on for security stuff for distributing software is the capability to answer “is this software produced from your company”? This led me to a rabbit hole for the signing mechanism for containers. The signing mechanism is somewhat similar to us install packages from rpm or deb repos for the various linux repos - there is a need to ensure that the package received is truly from the correct source.

Trying ZFS filesystems

Sun, 20 Jul 2025 00:00:00 +0000

There is a technical challenge and interesting requirement in my job that requires lightweight snapshot capability of a folder/set of files. Technically, it should be ok to simply create a volume snapshot on the cloud vendor of this - however - creating such snapshots actually take a lot of time and potentially, a lot of space - it’s not the cheapest solution for this.

GKE as Gitlab Runner

Tue, 08 Apr 2025 00:00:00 +0000

Part of my job involves me dealing with Gitlab on a daily basis. Gitlab is a complicated beast to handle and it took a while to get around the various features that the product offers. One of the offerings available is one where we can set an entire Kubernetes cluster as a potential target where we can then create containers and run tests on said cluster.

Configuring Compute Storage

Tue, 01 Apr 2025 00:00:00 +0000

When we initially start playing around with compute instances in the cloud, we generally just deploy instances without thinking too much about it. We don’t think about the application requirements or how CPU or Memory may require. But with experience, we then know the importance of providing sufficient resources to the applications that we install on the server - and a pretty huge one to think about the amount of storage we allocate to the server for our application.

Building RPMs and storing it in Artifact Registry

Wed, 27 Dec 2023 00:00:00 +0000

Introduction
#

When one mentions about application packaging - the usual first thought that can cross a person’s mind is how the application would be packaged in docker containers. That is a somewhat fair thing to think about - containers have gotten pretty common in developer circles. Tools such as docker or podman make it especially simple to write a simple straight forward file that would include their application file into a nice package. With this nice package - the people that are involved with running it production environments would only deal with a single artifact.

Github actions for shopping list application

Wed, 20 Dec 2023 00:00:00 +0000

I have a basic shopping list application that is available in the following code base: https://github.com/hairizuanbinnoorazman/Go_Programming/tree/master/Apps/shopping-list. This is a simple Golang application that also embeds a generated javascripts that has been transpiled into Javascript files. We can then embed the required CSS, Javascript and HTML files that would be the frontend of the shopping list. The frontend would then call some backend apis that would simply store shopping list items into some form of datastore - which in this case, is Google Cloud Datastore (a NoSQL database)

Using Terraform for deploying databases and applications in Google Cloud

Wed, 13 Dec 2023 00:00:00 +0000

Over the past few months, I have been toying with the idea of going all in with Ansible or all in with Terraform. Both tools are pretty popular tools when it comes to application and tools deployment. After tinkering around, I eventually somewhat come to conclusion where Terraform would be the “better” tool here. The main reason for this all comes down to this: https://github.com/ansible-collections/google.cloud/issues/301 - it seems that Ansible is not as “supported” as Terraform - and the more it seems that there are certain features that I may want to use to be missing. Rather than continue tinkering and hoping that something would happen (sometimes, these kind of code would never be resolved/fixed - it’s possible for me to dig into it to try to solve but I don’t feel like investing into this particular tool in depth)

Access Cloud SQL from Google Cloud Run without Serverless VPC Access Connectors but via VPC

Wed, 11 Oct 2023 00:00:00 +0000

Introduction
#

Previously, Serverless VPC Access connector is a commonly used solution to connect Cloud Run to Cloud SQL securely. This option is still available for use today but with all the previous blog posts that cover how we can:

Serverless Applications with Cloud Run with Serverless MySQL from PlanetScale

Wed, 27 Sep 2023 00:00:00 +0000

Serverless computing, as seen in platforms like Cloud Run or AWS Lambda, allows developers to run code without managing the underlying infrastructure. This is achieved by automatically scaling the resources based on the incoming requests, and users are billed based on the actual execution time and resources consumed during each function or container invocation.

Access Cloud SQL from Google Kubernetes Cluster without Cloud SQL Proxy

Wed, 20 Sep 2023 00:00:00 +0000

Introduction
#

Similar to my previous blog post, we would usually be connecting Google Kubernetes Engine (GKE) clusters to Cloud SQL databases by using the Cloud SQL Proxy. However, we can now use Private Service Connect, which allows for private communication between different Google Cloud services, similar to how we did for connecting our application in Google Compute Engine (VM) to a Cloud SQL instance.

Access Cloud SQL from Google Compute Engine without Cloud SQL Proxy

Wed, 13 Sep 2023 00:00:00 +0000

Traditionally, when connecting a Google Compute Engine instance to a Cloud SQL database, the Cloud SQL Proxy was commonly used to facilitate secure connections. The Cloud SQL Proxy acted as an intermediary between the application running on a Compute Engine instance and the Cloud SQL database. It helped to secure the connection by using the Cloud SQL IAM database authentication and provided a way to connect to the database using a Unix socket.

Persistance in Google Cloud Run with FUSE storage to Google Cloud Storage

Wed, 06 Sep 2023 00:00:00 +0000

Google Cloud Run is a serverless compute platform that automatically scales applications in response to traffic. It is designed to run stateless containers, meaning that the instances of your application are ephemeral and can be spun up or down as needed. This design choice has implications for data storage, particularly when it comes to persistence.

Accessing Google Compute Instances via Cloud Run

Wed, 30 Aug 2023 00:00:00 +0000

The typical way to access Google compute instances from Cloud Run is usually done via the Serverless VPC Access. However, setting this up would mean that we are essentially create an instance that would be used as a proxy to send traffic from Cloud Run to the Google Compute instance.

Using Emulators for testing Google Cloud Datastore integration

Wed, 26 Jul 2023 00:00:00 +0000

Motivation for finding emulator for Google Cloud Datastore
#

Many applications out there in the real world would require the use of databases to persist data. In the cases where an application depends on databases such as mysql or mariadb or postresql, we can create some form of “staging” server where we can test that the application works as expected. Additionally, we can even test to make sure that any database migration works as well without too much issues - we can import in some of the data from production and import it into the staging environment to make sure that it works.

Deploy Golang Apps that interact with headless service in Kubernetes

Wed, 12 Jul 2023 00:00:00 +0000

In certain application scenarios - there is a need to have applications that need to do client side load balancing to a bunch of servers. Such cases are pretty rare - but we won’t be covering the exect reasons or scenarios or when these are needed. Instead, we will cover how we can do so with Golang applications in Kubernetes cluster.

Trying to create MariaDB replica server

Wed, 28 Jun 2023 00:00:00 +0000

A common architectural pattern for relational databases is to create an additional replica server. This pattern usually come up due because most applications are usually read heavy - data is usually read to be presented to users.

Running kubectl in a Kubernetes Pod

Wed, 12 Apr 2023 00:00:00 +0000

I have a little side project at work where it somewhat requires me to allow a pod within a kubernetes cluster to access and query and manipulate resources in a Kubernetes cluster. This would provide some sort of special development environment within pod with the required capability to update the cluster. In order to do this, we need to add a bunch of roles, clusterroles and its bindings (essentially the RBAC system in Kubernetes) to allow the pod to access said resources

Creating a SSH Tunnel to expose a web application from a workstation

Tue, 31 Jan 2023 00:00:00 +0000

There are some cases where we would need to host an application on our workstation but need it to be exposed publicly so that people would be able to access the application over the internet. There could be a variety of reasons for this to happen; e.g. data locality (too much data to transfer to the cloud - it might cost too much to store it in public cloud), application sensitivity (there are certain aspects that might make it bad to have it only run from public cloud - there is a need for applicaiton to be available on local network if there is no internet available), or maybe application can only be run on certain types of environment (e.g. mac). Most cloud vendors usually only provide windows and linux - mac environments are a bit on the rare side.

Trying out Google Cloud Workflows

Mon, 10 Oct 2022 00:00:00 +0000

Over the recent weekends, I’ve decided to take a gander and try another “serverless” tool called Google Cloud Workflows. The tool’s appeal is to be able coordinate a bunch of services in order to achieve a particular goal. The coordination effort (or workflow) can easily get pretty complex -> one way would be to script but if we want to have the capability to have the button to run the entire workflow from start to end with logging in place as well as capability to run the workflow based on particular triggers.

Leader Election in Kubernetes via Kubernetes Configmaps and Leases

Sun, 28 Aug 2022 00:00:00 +0000

The leader election mechanism is a somewhat complex thing to kind of code up for an application. There are various Golang libraries that assist with this but it would be nicer if there were mechanisms within the environment that the application operate in which can help with this. In the case for the Kubernetes ecosystem - we can actual rely on the fact of how Kubernetes would usually etcd that does this leader election dance on our behalf. If we can tap on this mechanism, we can avoid introducing this mess of a complexity within our application.

Continuous Profiling of Applications in Kubernetes via Pyroscope

Fri, 05 Aug 2022 00:00:00 +0000

The whole process of profiling an application is an attempt to identify hotspots within the application which consumes more resources or takes too much time - knowing this would allow us to identify how to further improve the code within the applications that we build in order to build applications that consume less resources or would respond better to external inputs. Profiling of an application is just another aspect to improve observability of application’s performance on top of the common usual tooling such as distributed traces, metrics and logs. Tools such as distributed traces, metrics and logs only can capture part of the picture of how an application performs within an environment but is different for profiling. Profiling would point out what is happening “internally” within the application such as amount of memory being allocated for particular functions, how much CPU time is being taken for a particular function, thereby providing even more visiblity to how the application works.

Experimenting with IP Tables

Sun, 05 Jun 2022 00:00:00 +0000

While playing around with container technologies such as docker and kubernetes, one critical component that kind of comes up over and over again is the whole portion about managing network connections to the containers. If we are to just take an example of Kubernetes - the networking stack is handled by technologies that would interface with CNI as well kube proxy. In this post, we’ll be focusing on the linux feature that kube proxy kind of rely on (one of the modes that it runs on) which is IP Tables.

Restricting connections between pods in a Kubernetes Cluster (Network Policy)

Sun, 15 May 2022 00:00:00 +0000

There is an old adage from security land that we should restrict access to resources/assets as much as we can. Users and applications should only access items that they need to operate themselves. Following this line of thought, that would mean that if we are to deploy application in a Kubernetes Cluster, we should ensure that pods should only accept communication that they’ve explicitly declared as “required”. Is there a way to do so?

Private VPC Experimentation

Thu, 05 May 2022 00:00:00 +0000

This blog post is kind of a blog post that provide some notes of some experimentation that I encountered while playing with Google Cloud Platform. The purpose of this experimentation was to do the following:

Debugging Distroless Kubernetes Pods

Fri, 15 Apr 2022 00:00:00 +0000

There is a trend of images that follow the philosophy of minimizing the size of image by removing almost everything out of image. This helps with getting image downloaded more quickly by kubelet into the nodes as well as possibly reducing the attack surface of the container even further (I suppose it’s harder to do things in a container if utilities like shell or bash don’t exist within it). You would probably see errors such as this for those containers that have somewhat remove the shell/bash:

Kubernetes Ingress for applications with branded links on GKE

Sun, 13 Feb 2022 00:00:00 +0000

While dealing with branded links during my course of work, I kind of wondered how it can be tackled if I were to do it in a Google Kubernetes Engine Cluster. The situation I would imagine that would need to solve is this:

Bus Arrival App - Singapore

Thu, 03 Feb 2022 00:00:00 +0000

This is a quick sample tool to retrieve bus arrivals in Singapore. In order to use it, we would need to find for the Bus Stop ID or Bus Stop Code from where we’re taking the bus from. After keying it, it would fetch the records from LTA Datamall’s real time bus arrival API and present those records in this tool.

Database migration via Cloud SQL Proxy for Cloud SQL in Google Compute Engine VM

Mon, 17 Jan 2022 00:00:00 +0000

Database migration is kind of a critical bit when it comes to running and operating applications. In Golang, it is kind of appealing to rely on ORM (Object Relational Mapping) libraries. It allows one to kind of map structs to tabular structures within the database storage. One such example of an ORM library that I’ve found on the first page of Google is GORM.

Sending ggplot graphs to googleslides again

Sun, 07 Nov 2021 00:00:00 +0000

There was a change to the Google Slides API that resulted in an inability to upload images from Google Drive into Google Slides programmatically. Refer to the following issue on the rgoogleslides github repo - https://github.com/hairizuanbinnoorazman/rgoogleslides/issues/28.

RGoogleslides - using your own account client id and secret

Sat, 30 Oct 2021 00:00:00 +0000

NOTE: BEFORE READING THIS - ALL SCREENSHOTS BELOW ARE TAKEN SOMETIME IN OCTOBER 2021. THE UI MAY CHANGE IN THE FUTURE - USE THIS AS A ROUGH GUIDE AND NOT AS ABSOLUTE TRUTH

App with Metrics, Logs and Distributed Traces

Wed, 29 Sep 2021 00:00:00 +0000

In a previous post, it details some information of how to setup some open source tooling to capture logs, retrieve metrics as well as capture distributed trace information from apps. The previous blog post would cover the setup of logging system which is Loki, distributed tracing system which is Tempo and metrics collection system which is Prometheus. Refer to the link below here.

Setting up Observability Tooling in GKE

Wed, 01 Sep 2021 00:00:00 +0000

Generally, most cloud providers come along with all the observability tooling that you need for your apps built-in with the platform. Some of the common observability tools such as logging, monitoring and nowadays, distributed tracing are usually made available and you can easily use said tools by reading up on the various documentation of how to setup each of these tooling. E.g. if your application is inside a virtual machine and if you need collect metrics and logs from the application, you may need to install an agent in the said VM. The agent would collect those information and send it to the centralized observability tooling in the cloud provider where the information would be provided to you via a UI. Most of the time, these tools are charged based on the amount of logs/metrics you generate from the application (so the less logs/metrics you generate, the cheaper it is monitor your application - a very understanable/reasonable situation). In cases where if your application runs in Kubernetes, maybe the cluster comes with agents pre-installed, making it easier to make use of the logging/metrics/distributed tracing that the cloud provider has.

Using Envoy for GRPC Applications in Kubernetes

Thu, 15 Jul 2021 00:00:00 +0000

As of now, one of the common and easier way to have services communicate with each other would be over HTTP. In real world use cases, HTTPS is usually used (in order to ensure communications are secure) and this communication is done following some sort of REST framework. This provides some sort of structure of how to standardize such communications for the various software applications out there. It got to the point where entire companies are developing in order to support this: e.g. Apigee, SmartBear

Notes for building apps to be deployed on client infrastructure

Wed, 30 Jun 2021 00:00:00 +0000

This is definitely not an exhaustive list of items to consider but definitely some of the more obvious features that client side users would look out for and consider when attempting to install such third party apps and operate it on their infrastructure.

Building Nginx RPM from source

Sat, 01 May 2021 00:00:00 +0000

NOTE: As software advances, some of the commands shown below may become depreciated/irrelevant. If one encounters errors - check the output logs to see what the issue is (e.g. missing library? missing dependency? wrong folder structure due to being unable to find a file)

Python Flask Apps in Kubernetes

Sun, 18 Apr 2021 00:00:00 +0000

This are some notes in the case where one wants to deploy a bunch of python “microservices” to a Google Kubernetes Engine cluster. These notes emphasize on the basics rather than the various nuances of running a “production” grade python application.

Cloud Run Websocket support now allows you to deploy a R Shiny Server as a serverless app to GCP Cloud Run

Fri, 05 Mar 2021 00:00:00 +0000

Sometime earlier this year (2021), Google Cloud Run started to support websocket support - which is one of the critical components in order to be able to run a R Shiny Dashboard application.

Trying Distributed Tracing with Jaeger

Sat, 04 Apr 2020 00:00:00 +0000

Let’s say we have a set of applications that was designed to be a set of microservices. Each of the applications would generally be designed to be focused on one specific domain and in order to achieve the overall goal of the platform. However,for the platform to work properly, the applications would generally need to work together as one which would involve the application contacting each other.

Trying Knative from scratch

Mon, 09 Mar 2020 00:00:00 +0000

This blog post is still being updated

Various cloud providers started offering serverless containers as a service. This is a service where developers can just create a container and then, pass that container over to the cloud provider and then forget about it. The cloud provider would deal with the scaling, provisioning of resources to host the applications, deployment, monitoring etc.

Cookiecutter template for Google Cloud Run

Sat, 05 Oct 2019 00:00:00 +0000

While working on a couple of projects that would be deployed on Google Cloud Run, I realized that a couple of them tend to have some sort of similar structure. Due to the number of repositories I would typically handle on a personal basis as well as the amount of context switch I would need to move between projects; it would ideal that all of such projects are automated as much as possible.

SSH configurations for going into Google Cloud Instances

Thu, 01 Aug 2019 00:00:00 +0000

A classic move to reduce the attack surface of Google Cloud Instances is follow the advice below:

If service on instance don’t need Public IPs, don’t attach Public IPs to such instances
If instance requires Public IPs, ensure that only specific ports that are required are exposed. Clamp down on the rest of the ports and ensure no ingress on them

With these basic principles, it would be simple to think how these would eventually lead to an architecture where users access the instances via a bastion host. A bastion host is a instance that would allow user to ssh in from the “outside” world. The more critical instances would linked together in a private network that is unaccessible from the outside (except for load balancers to receive traffic etc).

Introduction to Google Cloud Run

Mon, 15 Apr 2019 00:00:00 +0000

There are various serverless compute solutions on the Google Cloud Platfrom; initially it used to be only Appengine and Google Cloud Function. Google Appengine is a solution that allow you to focus on writing up apps and allow Google to take of deployment/scaling/operations. Google Cloud Functions take a step further and allow you as a developer to develop just plain old functions and allow Google to handle the rest of it, thereby making it easier to split your app functionality to parts that require to scale and parts that don’t need to.

Private Go Modules in Google Cloud Build

Fri, 01 Mar 2019 00:00:00 +0000

So recently, I’ve been needing to automate my builds for my few Golang projects via Google Cloud Build. However, rather than building docker containers, I needed Golang binaries instead, which kind of meant that I would need to have the CI/CD pipeline have a Go environment/runtime to build them. However, when it comes to these CI/CD solutions, including private Golang packages/modules in siad projects is usually quite troublesome. Private Golang packages usually take the code from private Github/Bitbucket/Gitlab repos and getting the go get command to fetch them successful require a bit of hacks here and there to make it work successfully.

Setting up a Private Pypi Server

Fri, 01 Feb 2019 00:00:00 +0000

As one writes several python applications to be targeted on the Google Cloud Functions platform, it becomes increasingly obvious to pull out the more common bits of code out into its own library. Let’s have an example on the reason for this.

Preparing for Google Cloud Developer Certification

Sat, 26 Jan 2019 00:00:00 +0000

Recently, Google has been launching a couple of certification programs that would help people dictate their knowledge and expertise levels with the Google Cloud Platform. At the moment (January 2019), there are 7 certifications including Professional Cloud Architect, Cloud Developer and Professional Data Engineer.

Devops Tools with Google Cloud Platform

Mon, 14 Jan 2019 00:00:00 +0000

There are various tooling out there to make deployment of applications easier. Some tools are used in order to help developers and organizations attempt to reach the “12 factor app” standard of applications which are set of applications that are explicitly designed to be able to scale where needed.

Triggering analytics via Serverless Functions Part 2

Sat, 10 Nov 2018 00:00:00 +0000

This is a continuation of previous blog post.

To summarize the previous related blog post.

Too painful to have people respond and react to report generation and compilation
Too expensive to have machine lying around to pick up the slack and automate the reports; serverless solutions (pay on use) could be a useful model to use when running automated reports.
Scenario presented for example purposes: 3 reports generated which are to be compiled to a single report. Previously mentioned 3 reports would be processed on the condition when the data files are dropped into the storage buckets. Event generated from it would automatically run the report

Compilating reports
#

The next part of resolving our above mentioned situation (read previous blog post - part 1 for more details on this) is to compile the report. There are several ways to handle, each with their own advantages and drawbacks respectively. We would use the terms subreport to refer to reports for the initial set of reports that would then need to be compiled into a final report. These are just possible solutions; the combination of products that can be used to achieve the final goal of checking subreports and then compiling into the final report.

Triggering analytics via Serverless Functions Part 1

Tue, 06 Nov 2018 00:00:00 +0000

Seeing how functions change the way one looks at compute workloads in terms of products makes me wonder how one/companies can look at their analytics workloads and try to see if it was possible to change the costing model in that direction.

Getting Meetup Stats with Google Cloud Functions

Fri, 24 Aug 2018 00:00:00 +0000

Meetup.com is a pretty nice site to setup meetups and sharings on technologies. The platform is pretty nice and easy to use when it comes to bookings but sometimes, the data provided by its web interface is not sufficient nor does it fit our use case. In this case, let’s say you are trying to understand the trend of the number of people attending a meetup. To an organizer, an important thing to him/her is to understand what kind of actions would lead to higher turnups/registrations for a meetup. So, by the end of this post, hopefully we would be able to have a pretty decently priced (free if possible) solution for an analytics solution which would only be called occasionally.

Summary of Google Cloud Next 2018

Sun, 29 Jul 2018 00:00:00 +0000

Google recently had a Google Cloud conference where they feature all the exciting new technologies that are made available in Google Cloud. There are numerous product announcements that were mentioned in the various keynotes as well as the breakout sessions; so in an attempt to understand what’s exactly is happening in terms of major product releases, I did a textual overview of the videos with links to additional resources. This is to highlight some of the brand new google products and how they can be used to serve new business needs and capabilities.

Google Cloud on Experiment, Fail, Learn, Repeat

Using Alloy and Grafana for extracting metrics and pushing to dashboard

Deploy alloy to collect Node Metrics #

Container Signing Experimentation

Trying ZFS filesystems

GKE as Gitlab Runner

Configuring Compute Storage

Building RPMs and storing it in Artifact Registry

Introduction #

Github actions for shopping list application

Using Terraform for deploying databases and applications in Google Cloud

Access Cloud SQL from Google Cloud Run without Serverless VPC Access Connectors but via VPC

Introduction #

Serverless Applications with Cloud Run with Serverless MySQL from PlanetScale

Access Cloud SQL from Google Kubernetes Cluster without Cloud SQL Proxy

Introduction #

Access Cloud SQL from Google Compute Engine without Cloud SQL Proxy

Persistance in Google Cloud Run with FUSE storage to Google Cloud Storage

Accessing Google Compute Instances via Cloud Run

Using Emulators for testing Google Cloud Datastore integration

Motivation for finding emulator for Google Cloud Datastore #

Deploy Golang Apps that interact with headless service in Kubernetes

Trying to create MariaDB replica server

Running kubectl in a Kubernetes Pod

Creating a SSH Tunnel to expose a web application from a workstation

Trying out Google Cloud Workflows

Leader Election in Kubernetes via Kubernetes Configmaps and Leases

Continuous Profiling of Applications in Kubernetes via Pyroscope

Experimenting with IP Tables

Restricting connections between pods in a Kubernetes Cluster (Network Policy)

Private VPC Experimentation

Debugging Distroless Kubernetes Pods

Kubernetes Ingress for applications with branded links on GKE

Bus Arrival App - Singapore

Database migration via Cloud SQL Proxy for Cloud SQL in Google Compute Engine VM

Sending ggplot graphs to googleslides again

RGoogleslides - using your own account client id and secret

App with Metrics, Logs and Distributed Traces

Setting up Observability Tooling in GKE

Using Envoy for GRPC Applications in Kubernetes

Notes for building apps to be deployed on client infrastructure

Building Nginx RPM from source

Python Flask Apps in Kubernetes

Cloud Run Websocket support now allows you to deploy a R Shiny Server as a serverless app to GCP Cloud Run

Trying Distributed Tracing with Jaeger

Trying Knative from scratch

Cookiecutter template for Google Cloud Run

SSH configurations for going into Google Cloud Instances

Introduction to Google Cloud Run

Private Go Modules in Google Cloud Build

Setting up a Private Pypi Server

Preparing for Google Cloud Developer Certification

Devops Tools with Google Cloud Platform

Triggering analytics via Serverless Functions Part 2

Compilating reports #

Triggering analytics via Serverless Functions Part 1

Getting Meetup Stats with Google Cloud Functions

Summary of Google Cloud Next 2018

Deploy alloy to collect Node Metrics
#

Introduction
#

Introduction
#

Introduction
#

Motivation for finding emulator for Google Cloud Datastore
#

Compilating reports
#