Kubernetes has two techniques when deploying applications for external Access, Egress and Ingress. Egress is outgoing traffic from the pod, and Ingress is incoming traffic to the pod.

But here, we will talk about Ingress Controller in Kubernetes.

Ingress Controller

Kubernetes Ingress Controller is an L7 Load Balancer that allows a simple host or URL-based HTTP routing.
Usually, Kubernetes Ingress Controller always uses a third-party proxy. There are many Ingress Controller applications today, i.e.:

Nginx: Official ingress for NGINX and NGINX Plus
Kong: Nginx-based API Gateway or enterprise option using KongHQ
Istio: Ingress Gateway for Istio-enabled clusters
HAProxy: HAProxy Ingress Controller
F5: Support F5’s BIG-IP Container Ingress Services
Ambassador: API Gateway and L7 Load Balancer with Kubernetes Ingress support

Ingress Controller in ServerStadium

In ServerStadium Cloud, we can implement Ingress Controller using Nginx. In the previous article, we configured Rancher Kubernetes, which installed Nginx reverse proxy as the default Ingress Controller. Nginx is a popular option for simple HTTP/S routing and SSL termination cases.

This tutorial will teach using Ingress Controller, like routing http/s routing and installing SSL in Kubernetes.
With Rancher, we will create ingress with a simple click.

Below is step by step what we will do in this article:

a. Make sure Nginx Ingress Controller has been installed on Kubernetes
b. Create a new project with the name “IngressCR” and a Namespace named “IngressNS.”
c. Create two subdomains with the names apple.serverstadium.com  and orange.serverstadium.com
d. Install SSL in Kubernetes
e. Configure the Ingress controller for both subdomains with SSL
f. Configure Load Balancer in ServerStadium Cloud for both subdomains

A. Make Sure Nginx Ingress Controller has been Installed on Kubernetes

Before implementing Nginx Ingress Controller in ServerStadium Cloud, we must ensure that Nginx has been installed in our Kubernetes. When we deploy Rancher for the first time, make sure the cluster.yml already has the following line :

# Required for external TLS termination with
# ingress-nginx v0.22+
ingress:
  provider: nginx
  options:
    use-forwarded-headers: "true"

After Nginx has been installed in Kubernetes, we can verify it using Rancher Web UI

1. Change your namespace to ingress-nginx
2. Click Workload – DaemonSets, then we will see nginx-ingress-controller

B. Create a New Project with the Name “IngressCR”

Next step, we will create a new Project in Kubernetes.

1. Change the view using “All Namespaces” – Click “Cluster” – Click “Project/Namespaces” then Click “Create Project” Button

2. We will be redirected to the new Window. Fill Name of the Project with IngressCR, then click Create.

3. Next, we will create a new namespace for our website. In Project, IngressCR, click “Create Namespace” button.

4. In the new Window, fill the Name with “ingressns” to create our namespace.

Now we have namespace IngressNS in our Kubernetes server.

C. Create Two Subdomains with Names apple.serverstadium.com and orange.serverstadium.com

In the next steps, we will create two subdomains and a simple site for both websites because we only want to know how the Nginx Ingress Controller works with SSL.

Change our namespace to ingressns then we will create a deployment for both websites.

Click Workload – Deployment

The first subdomain fills the field as follows:

Namespace : ingressns
Name : apple
Container Name : nginx
Container Image : nginx
Ports  :
                Service Type : ClusterIP
                Name             : nginx-svc
                Private Container Port : 80
                Protocol : TCP

Then click Create. Please wait for a while until deployment creates the pods.

After Apple’s Deployment state is Active,  we can create a new deployment for orange.serverstadium.com with the same steps.

Below is the screenshot after we create two subdomains in Rancher.

D. Install SSL in Kubernetes

In the next steps, we will add our SSL certificate in Rancher.
Click Storage – Secrets, then Choose Create Button

In the new windows, we choose TLS Certificate

Fill in the field as follow :

Name : Cloudraya (name of your certificate)
Certificate : Insert your Private key and Certificate
Click Create

Below is the screenshot after we successfully added the certificate.

E. Configure Ingress Controller for Both Subdomains with SSL

After we configure the website and certificate, we are ready to create an ingress for both domains (apple.serverstadium.com and orange.serverstadium.com)

Please make sure our namespace is in ingresses. On the left page, choose Service Discovery – Ingresses, then click Create

In the new Window, fill the field as follow:
Name : apple.serverstadium.com
Request Host : apple.serverstadium.com
Path : Prefix
            /
Target Service :  apple
Port : 80

Select Certificates
Certificate-Secret Name: Choose serverstadium secret that we have created before.
Fill the hostname with apple.serverstadium.com
Then click Create

Below is the screenshot after we successfully created the Ingress

Please do the same step to create orange.serverstadium.com until we have two ingresses in Kubernetes

F. Configure ServerStadium Cloud Load Balancer

Like the previous article at this link, we assign Load Balancer IP Address for Rancher.
This IP Address is the same IP Address for Ingress Controller for Kubernetes.

Point A record of both subdomains to IP 202.43.248.249; then we can browse it via browser.

Wow, we have successfully created Ingress in Kubernetes with SSL in ServerStadium Cloud!

Get more applicable articles on tutorials in our Knowledge Base. Or, if you have questions, feel free to contact us!

The post Kubernetes Ingress Controller using SSL in ServerStadium appeared first on ServerStadium.

Create a Project in Rancher

Click Cluster Name; for this application, we choose local, then click Add Project button

Insert the project name with the name Website, then click Create

Add Namespace

Select Website project, then we create a namespace in which the application will be deployed.
Click Add Namespace button, then Insert Name with nginx-ns

Click the dashboard, then Choose Project Website

Click the Deploy button on the right side to deploy a simple application.

Fill in the value as the following screenshot
Name: nginx
Docker Image: nginx
Namespace: nginx-ns
Port Mapping:
    Port Name: nginx
    Public the container port: 80
    Protocol: TCP
“As a” : NodePort
Then click Launch

Let’s monitor until the deployment status is Active

After deployment is successful, the Nginx application uses port 30350. In the next step, we will add this port to the Load Balancer in ServerStadium Cloud

Add Port to Load Balancer

Create a Load balancer with Name nginx with Public Port 80 and the Private Port 30350

Edit nginx Load Balancer to assign All nodes

Edit nginx Load balancer, then assign all nodes to the LB

Add all nodes to the Load Balancer; we can access the Nginx using the IP Address of the Load Balancer

Scaling a pod using Rancher is very simple. We only need to click the plus button on the right side.

After a while, we will see two dots under Active which means the nginx already has 2 pods

Also, we can verify it using kubectl command. Please run the command below to verify the pods

# kubectl get pods

We can see the Rancher and kubectl command has the same result.

Add Helm Repository through Rancher

Helm is Package Manager of Kubernetes like apt and yum. We can add the repository and then choose the application that you would like to be installed. Click Apps, then choose Manage Catalogs.

After that, we will see the default three repositories of rancher

Click Add Catalog button to add the repository. In this tutorial, we will add the Bitnami Helm repository
Name: Bitnami
Catalog URL: https://charts.bitnami.com/bitnami
Helm Version: Helm v3

Then click Create

After Bitnami Repository has been added, we can continue to deploy the application.

Deploy / Launch Apache from Helm Repository

We will deploy Apache in the Kubernetes cluster. Click the Launch Button the search Apache

On the new screen, we will see many applications on Kubernetes. Just type Apache the click the Apache to continue the deployment

Fill the field as follow :
Name: apache
Namespace: apache
Then Click the Launch button

Click Apps to see the status of Apache deployment

Let’s find the service port of the Apache using kubectl in the Apache namespace

# kubectl get svc -n apache

In here, we get port 30560, which we can set on the Load Balancer of ServerStadium Cloud. Add new Load Balancer configuration as follow.

Then assign all nodes to this Load Balancer IP Address. Verify the Apache deployment by accessing the website using the URL

Finally, we successfully installed Kubernetes and deployed a simple application, Nginx and Apache, in ServerStadium Cloud.
Please feel free to submit your question to our Support if you need more assistance.

Missed something? You can always re-read the article part 1 and part 2. Ready to have your High Availability in Kubernetes Using RKE? Try it in ServerStadium Cloud now; sign up here.

The post High Availability Kubernetes Using RKE in ServerStadium Part 3 appeared first on ServerStadium.

1. Install Rancher in standalone docker
2. Install Rancher as a container under Kubernetes cluster itself

In this tutorial, we will install Rancher as a container deployed on the Kubernetes cluster on every node. If one of the servers is down, we can still access Rancher from our end.

Before we install the rancher, we need to install helm on the server.
Helm is package management for Kubernetes like apt. Please install Helm from the latest source, or we can install it using snap package on Ubuntu.

# snap install helm --classic

Add Stable Rancher Chart

After we install Helm, we can add the Helm chart repository. In this tutorial, we will use the stable repository.

# helm repo add rancher-stable https://releases.rancher.com/server-charts/stable

Create a Namespace for Rancher: cattle-system

The next step creates Kubernetes namespace with the name cattle-system where the Chart will be installed.
Namespace helps us organize clusters into virtual sub-clusters and is helpful when working with another team or sharing the project on the Kubernetes cluster.

#kubectl create namespace cattle-system

Install Cert-Manager

Rancher management is designed to use SSL/ TLS for a secure connection. There are three recommended options for TLS termination for Rancher.

• Rancher-generated TLS certificate. This option needs to install cert-manager into the cluster. Cert-manager will issue and maintain the certificate for Rancher, including generating CA certificate and signing the cert.
• Let’s encrypt. This option also needs cert-manager and combine with Issuer Let’s Encrypt to issue cert for rancher.
• Using own certificate. This option allows you to use private or public CA-signed certificate.

In this tutorial, we will use the option Rancher-generated TLS cert.

# kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v1.0.4/cert-manager.crds.yaml

Create a namespace for cert-manager.

# kubectl create namespace cert-manager

Add the Jetstack Helm repository.

# helm repo add jetstack https://charts.jetstack.io

Update the local helm chart repository.

# helm repo update

Now we can install the cert-manager

#helm install cert-manager jetstack/cert-manager  --namespace cert-manager

List pods status on cert-manager. Make sure all pods are running

# kubectl get pods --namespace cert-manager

Install Rancher Using Rancher-Generated Certificate

We are ready to install rancher using self-sign certificate. We will use domain rancher.serverstadium.com for self-generated certificate just for this tutorial. Please use the following command to install Rancher.

# helm install rancher rancher-stable/rancher --namespace cattle-system --set hostname=rancher.serverstadium.com

Monitor the deployment status using the following command.

#kubectl -n cattle-system rollout status deploy/rancher

After Rancher has been rolled out successfully. We can continue to the next step.

# kubectl -n cattle-system get deploy rancher

Add Port of Rancher to Load Balancer

Now Rancher has already deployed on the server, the next step is to configure the Rancher Web UI using Load Balancer in ServerStadium Cloud.
Please Click Networking – Load Balancer, then Click Add New Load Balancer with the name rancher80. Fill in the field for the new load balancer as follow:

After Load Balancer has been created with the name rancher80, edit the Load Balancer to assign it to All nodes.

Click the Assign New VM button the choose node1, node2 and ndoe3

Add new Load Balancer for port 443 with name rancher443

Edit rancher443, then assign all nodes to the load balancer as we did on rancher80.

Access from Browser

Don’t forget to create A record of your rancher domain to the Public IP of the Load Balancer.
After that, you can browse the domain name from your browser. In this tutorial, we use rancher.serverstadium.com

Please click Proceed if you get the warning message. Insert your password, then choose default View with Multiple Cluster.

Insert the Rancher Server URL

In the next article, we can deploy a simple application and learn how to add helm repository through Rancher.

You can re-read Part 1 to make sure you did not miss anything.
Next, we will continue to deploy simple applicationa in Kubernetes part 3

The post High Availability Kubernetes Using RKE in ServerStadium Part 2 appeared first on ServerStadium.

In short, Its function is to make us easy to configure, deploy, manage, or monitor the largest scale of a containerized application in different deployment environments.

Before we talk about containers, let’s talk about Docker because Docker is a popular application that is often used with Kubernetes.

Docker is an open-source application that only uses the required program and elements that a program needs to be a complete unit as an image.  We can use that image to run an application like Nginx, WordPress, etc.
The collection of these images we will call a Container.

The container will run on a pod, where the pod is the smallest deployable unit in Kubernetes.
Installing Kubernetes is tricky because there are multiple ways to install it. Also, Kubernetes deployments container creation is not limited to using docker. We can use another container runtime like CoreOS, Mesos, LXC, Podman, etc.

In RKE1 (Rancher Kubernetes Engine), we will use Docker as the container runtime to deploy Kubernetes with simple installation.

RKE1 is a CNCF-certified Kubernetes distribution that runs within Docker Container, and it will make us easier to install Kubernetes in our infrastructure with a single YAML file.

After Kubernetes has been installed, we will install Rancher to manage it.
Rancher has a nice web UI that we can use to add, manage, monitor, remove the nodes, create a deployment, create the persistent volume of Kubernetes, and many things.

In Part 1, we will deploy Kubernetes in ServerStadium Cloud as follow:

• Launch at least 3 VM on the ServerStadium Cloud for High Availability workload.
• Enable SSH passwordless login for each Kubernetes node.
• Install docker on each node.
• Download RKE binary file and configure the Kubernetes.

Launch at Least 3 VM on ServerStadium Cloud for High Availability Workload

For High Availability Kubernetes, we need three VMs as Kubernetes nodes in ServerStadium Cloud. Below is the specification for every node:

Operating System: Ubuntu 20.04
Memory: 4GB
CPU: 2 Core
Disk: 20 GB
Public IP Address only for node1 because we will install RKE from node1.
For node2 and node3, we only need the Private IP Address.

Below is the IP Address of every node:
node1 :
Public IP Address: 198.167.141.249
Private IP Address: 10.1.1.205

node2:
Private IP Address: 10.1.1.47

node3 :
Private IP Address: 10.1.1.238

Enable SSH Passwordless Login for Each Kubernetes Node

Before deploying RKE on the server, we must enable SSH passwordless for easy installation with a custom domain internal. Instead of remembering the IP Address, it’s easy to remember the node using its names.

# vim /etc/hosts

Let’s generate the ssh key pair using the following command.

# ssh-keygen

After generating the ssh keypair is completed, we can upload the Public key to each node using command ssh-copy-id
Please run the following command from node1.

# ssh-copy-id node3
# ssh-copy-id node2
# ssh-copy-id node1

Install docker on each node:
Since we need docker for Kubernetes, we will install it on every node using the following command:

Firstly, we need to update our repository and allow our server to access the Docker repository using HTTPS

sudo apt-get update && sudo apt-get install apt-transport-https ca-certificates curl software-properties-common -y

Add a GPG key to ensure the authenticity of the software package

# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Now, we can add Docker repository to our server and then install the stable Docker version using the following command :

# sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" 

# sudo apt-get update && sudo apt-get install docker-ce containerd.io -y

Download RKE Binary File and Configure the Kubernetes

Before we deploy Kubernetes on the server, we need to download rke binary from the following link.
Download latest rke from https://github.com/rancher/rke/releases/

# wget https://github.com/rancher/rke/releases/download/v1.2.12/rke_linux-amd64

Rename the file as rke

 # mv rke_linux-amd64 rke

Then, make rke as executable file

# chmod +x rke

In ServerStadium Cloud, we will create a simple cluster from three nodes using the following yml.

Create a simple cluster.yml

nodes:
    - address: node1
      user: root
      internal_address: 10.1.1.205
      role: [controlplane, etcd, worker]
    - address: node2
      user: root
      internal_address: 10.1.1.47
      role: [controlplane, etcd, worker]
    - address: node3
      user: root
      internal_address: 10.1.1.238
      role: [controlplane, etcd, worker]
services:
  etcd:
    snapshot: true
    creation: 6h
    retention: 24h
# Required for external TLS termination with
# ingress-nginx v0.22+
ingress:
  provider: nginx
  options:
    use-forwarded-headers: "true"

Save the file, then we can continue to deploy Kubernetes using the command rke up. The installation will take around 10-15 minutes.

# ./rke up

After the installation is completed. It will create three files, and please save them in a secure location:
rancher-cluster.yml: The RKE cluster configuration file that we have created previously.
kube_config_rancher-cluster.yml: The Kubeconfig file for the cluster.
rancher-cluster.rkestate: The Kubernetes Cluster State file

If you want to know the status of the cluster node, we can use the kubectl command.
kubectl is a command-line tool that we can use to send a command to the Kubernetes cluster.
kubectl is authenticating with the Master node and making API calls to perform various management actions.
Copy the kube_config_rancher-cluster.yml as a config file. You can follow the following steps:

# mkdir /root/.kube
# cp kube_config_cluster.yml /root/.kube/config

Now, install kubectl on the master node

# snap install kubectl --classic

Run kubectl command to get the status of the nodes

#kubectl get nodes

#kubectl get namespace

Now it has been deployed. Next step, we will install Rancher to manage our Kubernetes Server.
Let’s go to continue to the next part

The post High Availability Kubernetes Using RKE in ServerStadium Part 1 appeared first on ServerStadium.