DEV Community: Bryan Sazon

Golang: Check Equality of Unordered Slice Structs

Bryan Sazon — Thu, 18 Mar 2021 11:25:25 +0000

Playground: https://play.golang.org/p/5GJVPn3X8k7

package main

import (
    "fmt"
    "reflect"
)

type person struct {
    name string
    age  int
}

func main() {
    // Two equal slices but order is different
    aa := []person{{"foo", 1}, {"bar", 2}}
    bb := []person{{"bar", 2}, {"foo", 1}}
    fmt.Println(reflect.DeepEqual(aa, bb))
    fmt.Println(isEqual(aa, bb))
}

// Check and ensure that all elements exists in another slice and
// check if the length of the slices are equal.
func isEqual(aa, bb []person) bool {
    eqCtr := 0
    for _, a := range aa {
        for _, b := range bb {
            if reflect.DeepEqual(a, b) {
                eqCtr++
            }
        }
    }
    if eqCtr != len(bb) || len(aa) != len(bb) {
        return false
    }
    return true
}

Go - Convert Structs to Map

Bryan Sazon — Sun, 26 Apr 2020 08:26:04 +0000

This hack uses https://github.com/fatih/structs

package main

import (
    "fmt"

    "github.com/fatih/structs"
)

type User struct {
    FirstName string `structs:"first_name"`
    LastName  string `structs:"last_name"`
}

func main() {
    a := User{FirstName: "John", LastName: "Wick"}
    s := structs.New(a)
    m := s.Map()
    for k, v := range m {
        fmt.Println("key", k, "value", v)
    }
}

Output is:

key first_name value John
key last_name value Wick

How to get started with VIM efficiently!

Bryan Sazon — Thu, 16 Apr 2020 19:23:43 +0000

First, open your terminal app. If you are on MacOS, I highly recommend using iTerm2.

Then, type the vimtutor command.

vimtutor

Finally, start reading and follow the instructions.

vimtutor has 7 lessons. Try to complete at least 2 lessons a day.

That's all!

Cleaning up Zookeeper Logs and Snapshots

Bryan Sazon — Thu, 16 Apr 2020 08:17:11 +0000

Problem

Zookeeper’s logs and snapshots are mostly responsible for its high disk usage. If your team makes use of these snapshots for specific purposes, it makes sense to back them up using your tool of preference.

My team uses ClickHouse and it uses Zookeeper for replication. So in our case, we don't need to keep snapshots.

Solution

To clean up manually, all you have to do is run the cleanup script.

# Go to wherever zookeeper bin is installed in your server
cd /opt/zookeeper/bin 

# Run the script
./zkCleanup.sh -n 10

Where 10 is the number of old snaps/logs you want to keep, the value should be greater than or equal to 3.

Repeat the completed steps to all the Zookeeper replica server.

See the script for reference.

Visualize Google Cloud Billing data in Grafana with BigQuery

Bryan Sazon — Tue, 14 Apr 2020 16:28:58 +0000

Wouldn't it be nice to have your infrastructure GCP billing along with with your infrastructure monitoring dashboard?

Let's get started!

Export GCP Billing to BigQuery

Reference: https://cloud.google.com/billing/docs/how-to/export-data-bigquery

Summarized Steps

Create a BigQuery data set. GCP will save the Billing data here.

Go to Billing console and configure the Billing export.

BigQuery

First, let's ensure that the billing data are already exported.

Let's say we want to know how much cost was incurred per service from April 1, 2020. The SQL query would be this.

SELECT service.description as service, currency, sum(cost) AS cost
FROM `DATASET_NAME.gcp_billing_export_v1_*`
WHERE usage_start_time >= "2020-04-01 00:00:00 UTC"
GROUP BY service, currency
ORDER BY cost DESC

Example result

Grafana

Finally, use the example configuration to visualize the query in Grafana.

This is the equivalent query.

SELECT $__timeGroupAlias(usage_start_time, 1d),
  service.description AS metric,
  sum(cost) AS cost
FROM `DATASET_NAME.gcp_billing_export_v1_*`
WHERE $__timeFilter(usage_start_time)
GROUP BY 1, 2
ORDER BY 1, 2

$__timeGroupAlias and $__timeFilter are Grafana SQL macros.
The column that is aliased as metric will be the labels to be shown and grouped in the graph.

The End

Any question? Let me know in the comments section!

Thanks for reading!

Analyzing Google Cloud Egress Usage with VPC Logs, BigQuery and Grafana

Bryan Sazon — Mon, 13 Apr 2020 19:09:25 +0000

It is essential to have a dashboard that shows how much data are sent within and outside of your infrastructure because:

Data sent between two different zones has cost.
E.g. Regional GKE clusters.
Data sent between two regions has cost.
E.g. Inter-region communicating GKE clusters.
Data sent outside (internet) has a cost.
E.g. APIs responses at a high rate can incur a lot of egress cost.

See https://cloud.google.com/compute/network-pricing.

Solution

Aggregate the VPC Flow logs to BigQuery and visualize it in Grafana.

Enable VPC Flow Logs

Read and follow the simple guide from here https://cloud.google.com/vpc/docs/using-flow-logs#enabling_vpc_flow_logging.

Summary:

VPC Flow logs are enabled at the subnet level.
VPC Flow logs are sent to Stackdriver logs.
Logs must be sampled to reduce cost. See https://cloud.google.com/stackdriver/pricing?#table. Start with 90% sampling rate with 15 minutes interval.

If you are using terraform, this is what you may need:

resource "google_compute_subnetwork" "my_subnet" {
  #
  # ... some code here ...
  #

  enable_flow_logs = true
  log_config {
    aggregation_interval = "INTERVAL_15_MIN"
    flow_sampling        = 0.9
    metadata             = "INCLUDE_ALL_METADATA"
  }
}

Go to Stackdriver logs and wait for the VPC logs to show using this filter.

resource.type="gce_subnetwork"
logName="projects/<YOUR GOOGLE CLOUD PROJECT ID>/logs/compute.googleapis.com%2Fvpc_flows"

Export Logs to BigQuery

Create a new Logs router sink and name it vpc_flow_logs.

Choose the option to automatically create a BigQuery data set. If you follow the example, it will name the data set vpc_flow_logs.

Use the same logs filter for the sink.

resource.type="gce_subnetwork"
logName="projects/<YOUR GOOGLE CLOUD PROJECT ID>/logs/compute.googleapis.com%2Fvpc_flows"

Using BigQuery

Go to BigQuery console, and copy-paste the following example queries.

A little SQL knowledge is required. If the SQL queries are not working, please let me know in the comments section!

Query 1: How much internet bandwidth was transmitted from a VPC to a continent since the date 2020-04-01?.

SELECT CONCAT(jsonPayload.src_vpc.vpc_name, " vpc to ", jsonPayload.dest_location.continent)  AS vpc_dest,
       sum(CAST (jsonPayload.bytes_sent AS INT64)) AS bytes_sent
FROM `vpc_flow_logs.compute_googleapis_com_vpc_flows_*`
WHERE TIMESTAMP >= "2020-04-01 00:00:00 UTC"
  AND jsonPayload.dest_location.continent IS NOT NULL
  AND jsonPayload.dest_location.continent != ""
GROUP BY vpc_dest
ORDER BY bytes_sent

Example result

vpc_dest	bytes_sent
foo vpc to Europe	133674777320
bar vpc to Asia	3013921321
baz vpc to America	934811223

Query 2: How much infrastructure bandwidth internally was transmitted from one region or zone to another region or zone since the date 2020-04-01?

SELECT 
      TIMESTAMP_TRUNC(TIMESTAMP, HOUR) AS timestamp,
      CONCAT(jsonPayload.src_vpc.vpc_name, " ", jsonPayload.src_instance.zone, " to ", jsonPayload.dest_vpc.vpc_name, " ", jsonPayload.dest_instance.zone)  AS route,
       sum(CAST (jsonPayload.bytes_sent AS INT64)) AS bytes_sent
FROM `vpc_flow_logs.compute_googleapis_com_vpc_flows_*`
WHERE TIMESTAMP >= "2020-04-01 00:00:00 UTC"
  AND jsonPayload.src_instance.zone != ""
  AND jsonPayload.dest_instance.zone != ""
  AND jsonPayload.src_location IS null
  AND jsonPayload.dest_location IS null
GROUP BY 
timestamp, route
ORDER BY
timestamp ASC

Example result

route	bytes_sent
foo europe-west1-b to foo europe-west1-a	2132121
bar us-west1-a to foo europe-west1-b	765756
baz us-west1-a to bar europe-west1-b	634334

For column names reference, see vpc flow record format and stackdriver log format.

Using Grafana

It is required that you install and configure the BigQuery Datasource plugin first before proceeding.

Building the Graphs

Here, you need to change the example queries and make use of Grafana SQL Macros.

Changes:

$__timeGroupAlias(TIMESTAMP, 1h) is used to aggregate the TIMESTAMP column with 1 hour resolution.
The column name that will be aliased as metric will be the label that is shown or grouped within the Grafana graph.
$__timeFilter(TIMESTAMP) is used to use the Grafana time range filter as the TIMESTAMP value.
Numbers that represent the column order are used in GROUP BY and ORDER BY for simplification.

Build the Internet Egress graph

SELECT 
      $__timeGroupAlias(TIMESTAMP, 1h),
      CONCAT(jsonPayload.src_vpc.vpc_name, " vpc to ", jsonPayload.dest_location.continent)  AS metric,
       sum(CAST (jsonPayload.bytes_sent AS INT64)) AS bytes_sent
FROM `vpc_flow_logs.compute_googleapis_com_vpc_flows_*`
WHERE $__timeFilter(TIMESTAMP)
  AND jsonPayload.dest_location.continent IS NOT NULL
  AND jsonPayload.dest_location.continent != ""
GROUP BY 
1, 2
ORDER BY
1, 2

Build the Inter VPC Egress graph

SELECT 
      $__timeGroupAlias(TIMESTAMP, 1h),
      CONCAT(jsonPayload.src_vpc.vpc_name, " ", jsonPayload.src_instance.zone, " to ", jsonPayload.dest_vpc.vpc_name, " ", jsonPayload.dest_instance.zone)  AS metric,
       sum(CAST (jsonPayload.bytes_sent AS INT64)) AS bytes_sent
FROM `vpc_flow_logs.compute_googleapis_com_vpc_flows_*`
WHERE $__timeFilter(TIMESTAMP)
  AND jsonPayload.src_instance.zone != ""
  AND jsonPayload.dest_instance.zone != ""
  AND jsonPayload.src_location IS null
  AND jsonPayload.dest_location IS null
GROUP BY 
1, 2
ORDER BY
1, 2

The End

Ensure that you watch your Stackdriver logs ingestion rate to prevent unwanted cost!

Thanks for reading!

In my next post, I will write a guide on how to visualize GCP Billing data in Grafana.

References:

Another good alternative for Grafana is Redash.
https://cloud.google.com/blog/products/data-analytics/grafana-and-bigquery-together-at-last.

Kubernetes Pod Affinity rules in a nutshell

Bryan Sazon — Thu, 06 Feb 2020 09:53:40 +0000

Pod Affinity

If you have the time, you must read about Pod Affinity.

Problem

I do not want to run a specific workload (sensitive-workload) along with some disruptive workloads (mysql and prometheus) within the same node. I know that these disruptive workloads have the following pod labels:

app=mysql (default namespace)
app=prometheus (monitoring namespace)

kubectl get pods -l app=mysql -n default
kubectl get pods -l app=prometheus -n monitoring

Solution:

apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: sensitive-workload
  namespace: default
spec:
  template:
    metadata:
      labels:
        app: sensitive-workload
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values:
                - mysql
            topologyKey: "kubernetes.io/hostname"
          - labelSelector:
              matchExpressions:
                - key: app
                  operator: In
                  values:
                  - prometheus
            topologyKey: "kubernetes.io/hostname"
            namespaces:
              - monitoring

By default labelSelector will search within the same namespace of the workload. You can use the namespaces field to add more namespaces to look for.

Nginx Ingress Controller Load Balancing and Retry with proxy_next_upstream

Bryan Sazon — Mon, 20 Jan 2020 14:57:42 +0000

By default, Nginx/Nginx Ingress provides sensible default settings. In the real world, there are a few combinations of configurations that you must deliberately change according to different upstreams (your backend apps) behaviour.

Log format

Structured logging is always better if JSONified. This is documented here.

log-format-upstream: '{"ts": "$time_iso8601", "requestID": "$req_id", "upstreamAddr": "$upstream_addr", "proxyUpstreamName": "$proxy_upstream_name", "proxyAlternativeUpstreamName": "$proxy_alternative_upstream_name", "requestMethod": "$request_method", "requestUrl": "$host$uri?$args", "status": $status, "upstreamStatus": "$upstream_status", "requestSize": "$request_length", "responseSize": "$upstream_response_length", "userAgent": "$http_user_agent", "remoteIp": "$remote_addr", "referer": "$http_referer", "latency": "$upstream_response_time"}'

Unfortunately, error logs can not be customised in Nginx.

The power of proxy-next-upstream

In Kubernetes, upstreams are Pod IPs from each Kubernetes Services’ Endpoints in your Ingress configurations. They are watched and fetched periodically from the Kubernetes API. This way, a controller does not need to reload its nginx.conf every time an upstream Pod is restarted or deleted. See Avoiding reloads for reference. This means that Nginx Ingress Controller does not depend on DNS.

Example Scenario

Now, what if a request hits an Nginx Pod upstream that is being restarted or was deleted? Obviously, we expect Nginx to load balance properly to the next available Pod right? Yes, this is how it works.

A Pod with IP 10.8.9.11 is deleted.
Nginx tries to connect to this IP until the proxy_connect_timeout.
Nginx will then look at the proxy_next_upstream settings and see if the error matches any of its value. If there is a match, the request is retried to the next upstream (other IPs from the Kubernetes Service endpoints).

Retry configurations

config	custom	default
proxy-connect-timeout	3 (seconds)	5 (seconds)
proxy-next-upstream	error timeout http_502 http_503 http_504	error timeout
proxy-next-upstream-tries	3	3
proxy-next-upstream-timeout	0 (no limit)	0 (no limit)

Gotchas

If you are going to customise proxy-next-upstream-timeout, the value should be greater than the proxy-connect-timeout.

Observation

The first error logs.

2020/01/20 13:20:48 [error] 2224#2224: *133630 connect() failed (111: Connection refused) while connecting to upstream, client: 10.8.9.11 ...
2020/01/20 13:20:48 [error] 2224#2224: *133630 connect() failed (111: Connection refused) while connecting to upstream, client: 10.8.9.11 ...
2020/01/20 13:20:48 [error] 2224#2224: *133630 connect() failed (111: Connection refused) while connecting to upstream, client: 10.8.9.11 ...

... 3 seconds later ...

13:20:56 [error] 2190#2190: *133679 upstream timed out (110: Operation timed out) while reading response header from upstream, client: 10.8.9.11...

And then finally, Nginx still managed to make the request successful.

You should see something in the logs like.

{
  "upstreamAddr": "10.8.9.11:8080, 10.8.8.2:8080",
  "status": 200,
  "upstreamStatus": "504, 200",
  "latency": "3.001, 0.005"
}

Pod IP	status code	latency
10.8.9.11	504 (failed)	3.001
10.8.8.2	200	0.005

Summary

The $upstream_addr displays the upstream Pod IPs used during the retry. This means that in a single request context, multiple Pod IPs can be used.
$upstream_status shows that in the first upstream the response code is 504 which is included in our proxy_next_upstream settings as http_504.
$upstream_response_time shows the response time for each upstream that was used. The first one is 3 seconds which is also our proxy_connect_timeout duration.

Known Issues

Sometimes, identical IPs are used in the $upstream_addr. See https://github.com/kubernetes/ingress-nginx/issues/4944#issuecomment-575754005.

Golang: Defer Gotchas and Hack

Bryan Sazon — Tue, 23 Jul 2019 09:30:34 +0000

Sample Program

package main

import "fmt"

func main() {
    p := person{"john", 15}
    defer printPerson(p)
    updateAge(&p, 20)
}

type person struct {
    name string
    age  int
}

func printPerson(p person) {
    fmt.Printf("Name: %s, Age: %d", p.name, p.age)
}

func updateAge(p *person, newAge int) {
    p.age = newAge
}

Run the program.

$ go run main.go

Name: john, Age: 15

I was expecting 20, but I got 15. This is because "The arguments to the deferred function (which include the receiver if the function is a method) are evaluated when the defer executes, not when the call executes.". See effective go - defer.

This means that the time that defer printPerson(p) was called, that p is already set in stone.

Workaround

Now, put printPerson(p) under an anonymous function.


func main() {
    p := person{"john", 15}
    // defer printPerson(p)
    defer func() {
        printPerson(p)
    }()
    updateAge(&p, 20)
}

Run the program.

$ go run main.go

Name: john, Age: 20

Why? The documentation only says the arguments to the deferred function are evaluated when the defer executes. In the modified code above, that deferred function is the anonymous function, and not the function printPerson. Hack!

Go: Error handling and tracing with OpenCensus supported platforms

Bryan Sazon — Mon, 15 Jul 2019 07:58:41 +0000

errors

I want to share my drop-in replacement for github.com/pkg/errors.

I created this package to help my current team view the details of my Stackdriver traces with Stackdriver logs.

Goals

Add OpenCensus trace attributes when creating a new error.

Basic Usage

Drop-in replacement. Creating an error.

err := errors.New("msg") // Wrap .. Wrapf .. Errof ..

Creating an error with context useful for monitoring.

func main() {
    _, span := trace.StartSpan(context.Background(), "ExampleNewT")
    defer span.End()

    err := errors.NewT(span, "error")
    fmt.Println(err)

    if erctx, ok := err.(errors.Error); ok {
        fmt.Println(erctx.SourceLocation().Function)
        fmt.Println(erctx.SourceLocation().File)
        fmt.Println(erctx.SourceLocation().Line)
        fmt.Println(erctx.TraceContext().TraceID)
        fmt.Println(erctx.TraceContext().SpanID)
    }
}

Output

main.main
/Users/jb/Golang/src/github.com/bzon/errors/examples/main.go
15
d2d2b126d0474947821106525e32b6e0
1644b4b9be26c929

How I use it

package main

import (
    "context"
    "flag"
    "fmt"
    "os"
    "time"

    "contrib.go.opencensus.io/exporter/jaeger"
    "contrib.go.opencensus.io/exporter/stackdriver"
    "github.com/bzon/errors"
    "github.com/go-kit/kit/log"
    "go.opencensus.io/trace"
)

func main() {
    var useStackDriver = flag.Bool("stack-driver", false, "Use stackdriver instead of jaeger.")
    flag.Parse()

    // logging
    var logger log.Logger
    {
        logger = log.NewJSONLogger(log.NewSyncWriter(os.Stdout))
        logger = log.With(logger, "ts", log.DefaultTimestamp, "caller", log.DefaultCaller)
    }

    // tracing
    switch {
    case *useStackDriver:
        // stackdriver
        sd, err := stackdriver.NewExporter(stackdriver.Options{
            ProjectID: os.Getenv("GCP_PROJECT"),
        })
        if err != nil {
            panic(fmt.Sprintf("Failed to create the stackdriver exporter: %v", err))
        }
        defer sd.Flush()
        trace.RegisterExporter(sd)
    default:
        je, err := jaeger.NewExporter(jaeger.Options{
            AgentEndpoint:     "localhost:6831",
            CollectorEndpoint: "http://localhost:14268/api/traces",
            ServiceName:       "erroring-service",
        })
        if err != nil {
            panic(fmt.Sprintf("Failed to create the Jaeger exporter: %v", err))
        }
        trace.RegisterExporter(je)
    }

    trace.ApplyConfig(trace.Config{DefaultSampler: trace.AlwaysSample()})

    for {
        workerr := work(context.Background(), logger)
        if ec, ok := workerr.(errors.Error); ok {
            logger.Log(
                "message", ec.Error(),
                "logging.googleapis.com/spanId", ec.TraceContext().SpanID,
                "logging.googleapis.com/trace", ec.TraceContext().TraceID,
                "logging.googleapis.com/sourceLocation", ec.SourceLocation(),
            )
        }
        time.Sleep(3 * time.Second)
    }

}

func work(ctx context.Context, logger log.Logger) error {
    _, span := trace.StartSpan(ctx, "work")
    defer span.End()

    // error with context
    err := errors.NewT(span, "error")
    return err
}

You can also see the source code of the example server in github.

Useful for logging error with tracing context.

$ go run main.go | jq '.'

{
  "caller": "main.go:38",
  "logging.googleapis.com/sourceLocation": {
    "function": "main.work",
    "file": "/Users/jb/Golang/src/github.com/bzon/errors/examples/main.go",
    "line": 55
  },
  "logging.googleapis.com/spanId": "1eb9494ab1a7831c",
  "logging.googleapis.com/trace": "e97499da53ef2a8fdf9681beddbe3d64",
  "message": "error",
  "ts": "2019-07-15T09:37:06.885078+02:00"
}

Automatic annotations will be applied in supported tracing platform for OpenCensus.

Configure Nginx Ingress Controller to use JSON log format

Bryan Sazon — Fri, 31 May 2019 16:36:30 +0000

Problem

I'm running Nginx Ingress Controller deployed on GKE and I want to structure my web server logs so I can create metrics and alerts in Google Cloud Stackdriver.

References

Solution

If you are using GKE, there is already a Fluentd DaemonSet that forwards all container logs to Stackdriver.

All you need to do is ensure that Nginx Ingress Controller's ConfigMap has the following log-format-upstream settings:

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-ingress-controller
  labels:
    app: nginx-ingress
data:
  log-format-escape-json: "true"
  log-format-upstream: '{"timestamp": "$time_iso8601", "requestID": "$req_id", "proxyUpstreamName":
    "$proxy_upstream_name", "proxyAlternativeUpstreamName": "$proxy_alternative_upstream_name","upstreamStatus":
    "$upstream_status", "upstreamAddr": "$upstream_addr","httpRequest":{"requestMethod":
    "$request_method", "requestUrl": "$host$request_uri", "status": $status,"requestSize":
    "$request_length", "responseSize": "$upstream_response_length", "userAgent": "$http_user_agent",
    "remoteIp": "$remote_addr", "referer": "$http_referer", "latency": "$upstream_response_time s",
    "protocol":"$server_protocol"}}'

If you are deploying Nginx using the Helm Chart, the values file will look something like this:

controller:
  config:
    log-format-escape-json: "true"
    log-format-upstream: '{"timestamp": "$time_iso8601", "requestID": "$req_id", "proxyUpstreamName":
    "$proxy_upstream_name", "proxyAlternativeUpstreamName": "$proxy_alternative_upstream_name","upstreamStatus":
    "$upstream_status", "upstreamAddr": "$upstream_addr","httpRequest":{"requestMethod":
    "$request_method", "requestUrl": "$host$request_uri", "status": $status,"requestSize":
    "$request_length", "responseSize": "$upstream_response_length", "userAgent": "$http_user_agent",
    "remoteIp": "$remote_addr", "referer": "$http_referer", "latency": "$upstream_response_time s",
    "protocol":"$server_protocol"}}'

kubectl port-forward External Services using TCP Proxy in Kubernetes

Bryan Sazon — Thu, 02 May 2019 09:24:26 +0000

Synopsis

It is common that some of your Workloads connect to external services such as databases that run outside your Kubernetes Cluster. These external services are usually secured and deployed in a private subnet.

My team currently uses Google Kubernetes Engine and we use GCP Memorystore (Redis as a Service) for caching. For us to access Memorystore securely, we will have to provision a VM that will act as a bastion host but we found a better approach to deal with this.

Port-forwarding with TCP Proxy

All our services run in Kubernetes, and as much as possible we want to stick with the kubectl everything workflow when dealing with our services. All thanks to tecnativa/tcp-proxy, it makes TCP proxying really easy with Docker.

So basically, any external services that our Kubernetes Cluster can access can also be accessed locally by deploying this sucker.

WARNING: This can be a security flaw in your case, but not for us.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  labels:
    app: redis-proxy
  name: redis-proxy
  namespace: default
spec:
  selector:
    matchLabels:
      app: redis-proxy
  template:
    metadata:
      labels:
        app: redis-proxy
    spec:
      containers:
      - image: tecnativa/tcp-proxy:latest
        imagePullPolicy: Always
        env:
          - name: LISTEN
            value: ":6379" # The listen address that it will be exposed to.
          - name: TALK
            value: "10.1.1.5:6379" # Private address of Memorystore.
        name: redis-proxy
        resources:
          requests:
            cpu: 10m
            memory: 10m
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}

With the tcp-proxy deployed, we can now just port-forward the tcp-proxy Pod.

kubectl port-forward redis-proxy 6379:6379

And access Memorystore locally using redis-cli.

redis-cli -p 6379