Random Ramblings

Run Kubernetes clusters across AWS and vSphere with TKG

Wed, 06 May 2020 00:00:00 +1000

It is common for many large organizations to run their Kubernetes workloads on more than one cloud provider. It is a great strategy to utilise the benefits of on-prem and public cloud. In this blog, I will show you how to create, run and manage clusters across AWS and vSphere using Tanzu Kubernetes Grid (TKG).

Brief intro to TKG

TKG is a bundle of tools that help run k8s in a production environment. In addition to vanilla kubernetes, TKG includes Open Source tools like Cluster API, Calico for networking, Fluent Bit for logging, Contour for ingress etc.

Prerequisites

Deploy TKG management cluster to Amazon EC2 - Follow steps in docs
Deploy TKG on vSphere - Follow steps in docs Alternatively, if you are on vSphere 7, you could enable kubernetes Workload management and skip step and follow this link to add vSphere management cluster to your TKG cli.

Multiple TKG management clusters

Now that we have set up two different TKG clusters, lets see how we can manage them using the TKG cli.

tkg get management-cluster

+-------------------------------+---------------------------------------------------------------+
| MANAGEMENT CLUSTER NAME       | CONTEXT NAME                                                  |
+-------------------------------+---------------------------------------------------------------+
| tkg-mgmt-aws-zzzzz*  | tkg-mgmt-aws-zzzzz-admin@tkg-mgmt-aws-zzzzz |
| wcp.vsphere.test.io  | wcp.vsphere.test.io                         |
+-------------------------------+---------------------------------------------------------------+

indicates the management cluster which is selected. AWS management cluster is selected at the moment.

Create a cluster on AWS:

tkg create cluster my-aws-cluster --plan=dev --kubernetes-version=v1.17.3+vmware.2

Once it is done, run the following command to make sure the cluster is created. tkg get cluster

+----------+-------------+
| NAME | STATUS |
+----------+-------------+
| my-aws-cluster | Provisioned |
+----------+-------------+

Create a cluster on vSphere:

Select the vSphere k8s cluster

tkg set management-cluster wcp.abc.test.io

To create a cluster in vSphere,

tkg create cluster my-tkg-cluster --plan=dev --namespace=demo --kubernetes-version=v1.16.8+vmware.1-tkg.3.60d2ffd

Once the cluster is created, you could verify by running the command or you could login to the vCenter UI to take a look.

Key takeaways:

I could use different versions of kubernetes across AWS and vSphere.
I could use different storage classes across AWS and vSphere. Edit ~/.tkg/config.yaml to change storage classes or vm classes.
Consistent experience creating clusters across the two IaaS. I can use the same TKG Cli to manage clusters. Yay!

Kubernetes vs Containers

Sat, 14 Mar 2020 00:00:00 +1100

If you interact with Software development teams as a part of your role, you would have heard the term Kubernetes (or 'K8s' as it is fondly known). This is a complicated concept to understand, especially if you do not have a Software Engineering background.

Last week, I was in a meeting with a few non-technical colleagues who were sharing customer stories around containers and Kubernetes. They were using jargon like containers, docker, kubernetes in this conversation.

A curious colleague who was listening in turned to me and asked “What is the difference between a Container and Kubernetes?” There was silence in the room, everyone eagerly waiting to hear this technical person’s answer.

The easy answer — Docker is used to create containers and Kubernetes is used to orchestrate them. I could get away with this explanation, but that is just throwing more tech jargon to the fire. How can you clearly articulate the differences between these technologies, let alone explain these concepts in a human-friendly, digestible way?

Background

Let’s say, we are building a simple website called chatter.com where people can post short updates about their life.

Here the engineers build this application in a programming language like java. They get it working on their machine, but you cannot see what they have built until this software application is available on the internet. Hence, this software needs to be deployed somewhere.

This application can be deployed on the company’s cloud infrastructure — it’s just computers on someone else’s hardware.

Since the application is written in java, the computer needs java to run the website. The engineers therefore package this application with java, so that it can be run on any computer just like it runs on the engineer’s machine.

This package is called a container. Just like regular airtight food containers, containers in the digital world come in different shapes and sizes. Based on the size of containers, more than one container can run on a computer.

We have our chatter.com running with containers. So what’s the deal with Kubernetes?

Containers to Kubernetes

For the next part, let’s pretend that the Cloud Infrastructure is like a 2x2 storage unit, where each shelf is a computer. Containers are just boxes. There are already a few (black coloured) containers on these shelves.

Each cube is a computer. Pink box is the chatter container

Engineers write scripts to drop the chatter container on an available shelf in the storage unit. This container is running on the top-right shelf (the pink container in the image).

Now, imagine there is an earthquake and this container suddenly crashes to the floor. Yep, sometimes websites crash too! Someone has to repeat the previous step again to replace the container.

How great would it be if there was someone watching over all these containers, making sure they are always running well? Enter Kubernetes to the rescue.

Kubernetes healing a burning pod

When a container crashes, k8s tries to heal the container and brings it back to life. It makes sure all containers are healthy and safe. K8s helps with finding a vacant spot for containers and allocates them to the appropriate shelf based on its size; ensuring the optimal use of shelf space.

This is a very high level differentiation between containers and k8s. There is more to k8s than allocating compute to containers. If you are interested in learning more, please leave a comment. I will share more details in subsequent posts. :)

How to test state in React components?

Mon, 09 Jul 2018 00:00:00 +1000

Do not test the state!

Although it is tempting to use state() from enzyme to test the value of your component state from jest tests, it is a code smell to do so. Because, state is internal to the component. Testing the new value of state from your unit test is like testing private methods (in java/ruby..).

How else do I test state change?

Now that is a different question.

When writing unit tests in jest/jasmine, it is a good practice to describe the behavior of your component. Tests are documentation after all. state is an internal detail of how you have implemented the functionality.

Example:

class Counter extends Component {
    constructor(props) {
        super(props);
        this.state= {
            count: 1
        };
    }
    
    increment = () => {
        this.setState((prevState) => ({count: prevState.count + 1}));
    }
    
    render() {
          return (
            <div>
                  <h2>Number of votes: {this.state.count}</h2>
                    <p> This is my code. Please upvote!</p>
                    <button onClick={this.increment}>Upvote!</button>
             </div>
            );
    }
}

In the example above, clicking on the button increments the number of votes on screen.

To test this in jest,

it('updates number of votes', () => {
  const wrapper = shallow(<Counter/>);
  
  wrapper.find('button').simulate('click');
  wrapper.update(); // Read: enzyme update
  
  expect(wrapper.find('h2').text()).toEqual('Number of votes: 2');
});

To conclude, use your tests to verify the behavior and not the implementation.

What is your take on testing state changes? Let me know in the comments below! Happy coding :)

Circuit Breaker Pattern

Sun, 23 Jul 2017 00:00:00 +1000

With Micro-services pattern, we rely more on the availability of services to connect with. Even if the services being consumed are written in a way to handle errors gracefully, there is a few more factors, like Network Connections, which could break your application. This makes it important to anticipate and handle failures when interacting with external systems.

The idea is similar to the Circuit Breaker in electrical systems. When you try to consume more electricity than the treshold, the fuse would blow up, leaving the electric circuit open. This prevents you from overloading the electrical circuit again. You need to close the circuit (with a copper wire) before you can consume electricity.

Circuit Breaker pattern is similar. If a remote system is unhealthy, the circuit is left open, so that your application does not wait for a timeout from the remote system repeatedly.

The difference with Circuit breaker in Software is that, there is no need for a human intervention in fixing the circuit. After a certain amount of time, the circuit breaker goes to a half-open state, in which the next call to the remote system is made to the remote system. If this call passes, the circuit gets closed. Else, it remains open.

Don’t do it if it hurts!

This post is based on the book Release It! by Michael T.Nygard.

The time I started running

Sat, 03 Jun 2017 00:00:00 +1000

I remember running my first 8 km and not being able to walk the whole day after. I thought I was just not fit. I tried multiple times, with short distance and long distance running. But my feet hurt so bad that I gave up on running.

A lot of articles suggested that I need better shoes. I bought a pair from Decathlon (40 AUD). It was so comfortable for my zumba classes. I decided to give running another chance. But, Zumba shoes are not running shoes.

I tried couple more shoes from big brands like Nike & Reebok. They were amazing for weight training. But horrendous for running.

At this point, I thought it was just me. My feet are not designed for running.😒

Few months later, I fell in love with a Nike running shoe, the moment I tried it on. They were so weightless and the soles were thick and comfortable.

The same day I went for a run.
I felt like a child who just started running.
My feet did not hurt!!
It made a huge difference in the way I looked at running.
It motivated me to keep running.

Choosing the right shoes make a huge difference. Those pair of shoes I am comfortable in, may not be the right fit for you. Running shoes are an investment.

It takes time to find your flavor. Don't settle for less comfortable, cheap shoes.

Keep searching for those perfect shoes.👟

Training that voice in my head

Fri, 02 Jun 2017 00:00:00 +1000

Ouch. Did I hear my ankle crack?
OMG. It could be a sprain.
I could have torn some ligaments.
Let me stop here.
Water. I need water!

Argh. Not even half way there?
Why not just turn around?
Why do I breathe so fast?
Is it normal to breathe through my mouth?

Phew. Made it half way.
Do I have to go back right now?
I can't feel my legs!!
I am going to fall on my face.
Oooh. Gelato house.

We are almost done.
Actually, my legs don't hurt so bad.
I feel alive; very much alive.

Why was I so negative about running anyway?

Break Stereotypes

Sat, 11 Mar 2017 00:00:00 +1100

“Boys will be boys
Play with the girls”

says mom to 5 year old Sarah when she complains about being teased by the boys, for missing a wicket at the cricket game.

This creates a fear in her heart.

A fear which makes her find boys intimidating. A fear which stops her from getting better at a game she really wants to play.

10 years later, this fear stops her from taking a class she wants to take, Because the same “boys” are in it. She is not matured enough to take the road less taken; She wants to be at a place which she considers her safe zone.

15 years later, this fear stops her from learning to code, Because she has not seen many women who are good at it.

Stereotypes are created by us. They affect our decisions. They affect our way of life.

Break Stereotypes

Tue, 07 Mar 2017 00:00:00 +1100

Dear women,

Don't get carried away by the stereotypes set by media;
Nobody but you can define what you are capable of.

Don’t be intimidated by the men in the floor;
Your skills are equally important as theirs.

Don’t be afraid of being wrong;
Everyone makes mistakes and so will you.

You are strong. You are beautiful;
Feel free to express yourself.

Let not the stereotypes stop you from expressing yourself.

This International Women’s day, I pledge to be bold for change and challenge stereotypes.

#BeBoldForChange

Connect with MergeProps

Thu, 02 Mar 2017 00:00:00 +1100

MergeProps is the third argument to the connect function. It is a function which is used to select a slice of the props from state and dispatch.

SaveAllContainer maps the todo items from store to props and a save prop which dispatches an action to save all items.

const mapStateToProps = (state) => {
    return {
        items: state.items
    };
};

const mapDispatchToProps = (dispatch) => {
    return {
        save: (items) => dispatch({type: "SAVE_ALL", items})
    };
};

const SaveAllContainer = connect(mapStateToProps, mapDispatchToProps)(SaveAll);

const SaveAll = ({save, items}) => {
    return <button onClick={() => save(items)}>Save All </button>;
};

items is being passed to the component and back to the container. But, the presentational component does not need to know about the items.

I would like it, if the save function in props knows about the items to be saved, so that the items need not be passed in props. Ideally, the container should return something like this:

{
    save: () => dispatch({type: "SAVE_ALL", items: state.items})
}

The best place to combine state and dispatch is mergeProps.

const mapDispatchToProps = (dispatch) => {
    return {
        dispatchSave: (items) => dispatch({type: "SAVE_ALL", items})
    };
}

const mergeProps = (propsFromState, propsFromDispatch, ownProps) {
    return {
        save: propsFromDispatch.dispatchSave(propsFromState.items)
    };
};

const SaveAllContainer = connect(mapStateToProps, mapDispatchToProps, mergeProps)(SaveAll);

The SaveAll component is not aware of the items anymore. mergeProps is now responsible for passing the items to be saved.

When the third argument is not passed to connect, the default implementation of mergeProps combines the ownProps, mapStateToProps and mapDispatchToProps.

mergeProps is where you can filter the props being passed to the component. Especially in situations like above, where you intend to use properties from store as parameters to dispatch actions, mergeProps is the cleanest choice.