Try Mirantis Kubernetes Engine

Mirantis Kubernetes Engine (formerly Docker Enterprise/UCP) is full-featured enterprise Kubernetes, complete with a management webUI (Universal Control Plane – UCP), Calico container networking, and NGINX Ingress. It’s built on Mirantis Container Runtime (formerly Docker Engine – Enterprise) – the leading enterprise container engine, with Content Trust and built-in FIPS 140-2 encryption, certified with a DISA STIG. Mirantis Kubernetes Engine can run Linux and/or Windows worker nodes (manager nodes run on Linux), and provides Kubernetes, Swarm, or mixed orchestration on workers. Plus, Mirantis Kubernetes Engine can host Mirantis Secure Registry (formerly Docker Trusted Registry) for a complete, self-contained software supply chain.

For enterprises that need to manage consistent Kubernetes at scale, infrastructure management platform Mirantis Container Cloud is the best tool for deploying Mirantis Kubernetes Engine. But for individual Kubernetes Engine clusters, Mirantis Launchpad can get you up and running quickly. Mirantis Kubernetes Engine itself can run acceptably well on medium-sized virtual machines in a home lab (e.g., hosted on VirtualBox), and runs very well on larger VMs on any private or public cloud. Note: if you’re seeking a very light Kubernetes that even runs on Raspberry Pis, a better choice is k0s — zero-friction Kubernetes.

About Mirantis Launchpad

Mirantis Launchpad is a command-line deployment and lifecycle-management tool that runs on virtually any Linux, Mac, or Windows machine. You can use it to install, deploy, modify, and update Mirantis Kubernetes Engine clusters on almost any set of bare metal or virtual machines running a supported operating system. This tutorial uses Ubuntu 18.04 LTS servers as targets, and provides instructions that should work on any private or public cloud. We also provide a configuration that works on desktop virtual machines running on VirtualBox.

Prerequisites

• A Mac, Linux, or Windows physical or virtual machine on which to run the Launchpad deployer. We recommend Ubuntu Linux. Instructions for configuring an appropriate VM can be found in our How to Build a Kubernetes Development Environment tutorial.

• Several virtual machines running Ubuntu Server onto which to deploy Mirantis Kubernetes Engine. Machines must be visible to the deployer on their private or public IP addresses. A reasonable minimum cluster can be constructed with one manager node and one worker node. These machines can be launched on AWS (see our Launch Virtual Machines on AWS tutorial) or on a desktop virtualization platform like VirtualBox (see our How to Create a Server on VirtualBox tutorial).

• Target machines must be configured for access via SSH using keys instead of passwords, and for passwordless use of sudo for the administrative account. This is the standard for AWS EC2 VMs.

Minimum Hardware Requirements for MKE nodes

• 8GB of RAM for manager nodes

• 4GB of RAM for worker nodes

• 2 vCPUs for manager nodes

• 25GB of free disk space.

Production Hardware Requirements for MKE nodes

• 16GB of RAM for manager nodes

• 4 vCPUs for manager nodes

• 25-100GB of free disk space. SSD is recommended.

Step 1: Set up your bootstrap machine

See our How to Create a Server on VirtualBox tutorial for a recommended recipe.

Step 2: Configure and launch hosts

This trial recipe assumes you’ll be creating a minimal Mirantis Kubernetes Engine cluster with one manager node (on which regular workloads, by default, cannot be scheduled) and at least one worker node. Provided the nodes are sufficiently resourced, this will let you use most of Mirantis Kubernetes Engine’s basic features for Kubernetes development. A three-node cluster will let you install Mirantis Secure Registry on the third node, for a complete, minimal solution with private container registry.

Note that larger, more resilient, and easier-to-operate clusters are also easy to create with Launchpad, and even easier to create with Mirantis Container Cloud. A cluster with three managers lets you update manager nodes without temporarily losing access to the Kubernetes Engine webUI or Kubernetes API. Depending on loading, node types, tagging restrictions on scheduling and other variables, additional worker nodes can collectively provide enough free and usable resources to permit non-disruptive rolling updates of workers (i.e., workers get updated while Kubernetes automatically moves parts of your applications around to keep applications online).

If you’re deploying target servers on AWS, you’ll want to follow our Launch Virtual Machines on AWS tutorial for complete details. This includes some suggestions about how to set up security groups.

If you’re deploying target servers on desktop virtualization from standard .isos, you’ll want to follow the instructions in our How to Create a Server on VirtualBox tutorial.

Step 3: Download Assets

Now that your hosts are running and reachable, return to your bootstrap machine. Fill out the form below, and download the appropriate version of Launchpad. You may wish to save the binary in a new directory like /home/ubuntu/launchpad, where ‘ubuntu’ is your administrative username. Optionally, it’s convenient to rename the downloaded binary (which has a name like ‘launchpad-linux-x64’) to something easier to type (e.g., ‘launchpad’).

Download Launchpad Deployer for Mirantis Kubernetes Engine

Now move to that directory (i.e., cd /home/ubuntu/launchpad).

cd /home/ubuntu/launchpad

Next, make the binary executable. On Linux, this can be done by typing:

sudo chmod +x launchpad

Optionally, it may also be convenient to add the application (temporarily or permanently) to your path so you can invoke it from anywhere in your directory hierarchy. This can be done temporarily by entering:

export PATH=$PATH:/home/ubuntu/launchpad

Once installed, verify installation by issuing the command:

./launchpad version

Register Launchpad

Next, you’ll need to register Launchpad by entering:

./launchpad register

… and entering the requested information as shown below.

john@john-VirtualBox:~/launchpad$ ./launchpad register
> Name John Jainschigg
> Email jjainschigg@mirantis.com
> Company Mirantis
> I agree to Mirantis Launchpad Software Evaluation License Agreement https://gi> I agree to Mirantis Launchpad Software Evaluation License Agreement https://github.com/Mirantis/launchpad/blob/master/LICENSE Yes
INFO Registration completed!

Fill out the required fields and accept the license agreement. Information provided here is used to assign evaluation licenses.

Step 4: Create a Launchpad configuration file for your Mirantis Kubernetes Engine cluster

In this example, we set up a simple, two-node Mirantis Kubernetes Engine cluster with Kubernetes orchestration (MKE worker nodes can also be set to Swarm orchestration, or configured for mixed, Swarm+Kubernetes orchestration). Launchpad is configured by providing a YAML file called launchpad.yaml. You can use Launchpad to generate a template for this file by issuing the command:

./launchpad init > launchpad.yaml

Deploy Mirantis Kubernetes Engine on AWS

The configuration file shown below should work on AWS or most public clouds. You’ll need to replace node IP addresses with the public IP addresses of your hosts, and provide a username and password that you’ll later use to log into the Mirantis Kubernetes Engine webUI.

apiVersion: launchpad.mirantis.com/mke/v1.3
kind: mke
metadata:
 name: my-mke-cluster
spec:
 hosts:
 - ssh:
 address: 172.31.21.69
 user: ubuntu
 port: 22
 keyPath: ~/.ssh/id_rsa
 role: manager
 - ssh:
 address: 172.31.18.12
 user: ubuntu
 port: 22
 keyPath: ~/.ssh/id_rsa
 role: worker
 mke:
 version: 3.6.1
 installFlags:
 - --admin-username=admin
 - --admin-password=sekretstuff
 mcr:
 version: 20.10.15
 cluster:
 prune: false

Launchpad configuration file for deploying a two-node, manager and worker cluster on cloud virtual machines with Class B (i.e., starting with 172.16. … ) IP addresses. In such cases, the default Kubernetes Pod CIDR doesn’t overlap with node IPs. Note that you must supply your username for each node (on AWS, for example, this is set by default to ‘ubuntu’).

Deploy Mirantis Kubernetes Engine on VirtualBox

If you’re deploying on VirtualBox or other desktop virtualization solution and are using ‘bridged’ networking, your nodes will typically have IP addresses in the Class C (i.e., starting with 192.168. …) range, making them overlap with default Pod IP addresses. In such cases, you’ll need to make a few minor adjustments to your launchpad.yaml (see below) — deliberately setting a –pod-cidr to an unoccupied range (in the example, we’re using –pod-cidr 10.0.0.0/16).

apiVersion: launchpad.mirantis.com/mke/v1.3
kind: mke
metadata:
 name: my-mke-cluster
spec:
 hosts:
 - ssh:
 address: 192.168.1.30
 user: my_username
 port: 22
 keyPath: ~/.ssh/id_rsa
 role: manager
 - ssh:
 address: 192.168.1.31
 user: my_username
 port: 22
 keyPath: ~/.ssh/id_rsa
 role: worker
 mke:
 version: 3.6.1
 installFlags:
 - --pod-cidr="10.0.0.0/16"
 - --admin-username=admin
 - --admin-password=sekretstuff
 mcr:
 version: 20.10.15
 cluster:
 prune: false

Launchpad configuration file for deploying a two-node, manager and worker cluster on VirtualBox VMs with Class C (i.e., starting with 192.168. … ) IP addresses. In such cases, the default Kubernetes Pod CIDR overlaps with node IPs, so must be reset to a non-overlapping range. You will probably also need to provide the admin username you chose when installing Ubuntu on node VMs (not set automatically to ‘ubuntu’).

Step 5: Bootstrap Mirantis Kubernetes Engine

Once the launchpad.yaml file is ready, we can tell Launchpad to deploy it:

./launchpad apply

Within a few minutes, you should have your cluster up and running. Launchpad exits by displaying information required to connect to your new Mirantis Kubernetes Engine cluster:

INFO[0021] ==> Running phase: MKE cluster info
INFO[0021] Cluster is now configured. You can access your admin UIs at:
INFO[0021] MKE cluster admin UI: https://test-mke-cluster-master-lb-895b79a08e57c67b.elb.eu-north-1.example.com
INFO[0021] You can also download the admin client bundle with the following command: launchpad client-config

Step 6: Connect to the Mirantis Kubernetes Engine WebUI

Navigate a browser to the provided URL, and log in with the username and password you provided in your launchpad.yaml file. Click ‘Skip for Now’ on the license warning that pops up. You’ll find yourself at the Mirantis Kubernetes Engine mainpage (see illustration).

 At this point, you can explore Mirantis Kubernetes Engine by following our documentation, or read on.

Step 7: Download a client bundle for your user

Navigate to the My Profile item in the Admin menu (left side) and you’ll see an option to create and download a new Client Bundle for the currently-logged-in user. This is an archive of access assets, including a kubeconfig. You can also use Launchpad to download this client bundle for your admin user. Return to your bootstrap machine and enter:

./launchpad client-config

You’ll get results that look like this:

INFO ==> Running phase: Open Remote Connection
INFO [ssh] 172.31.21.69:22: testing connection
INFO ==> Running phase: Detect host operating systems
INFO [ssh] 172.31.21.69:22: is running Ubuntu 18.04.5 LTS
INFO ==> Running phase: Gather Facts
INFO [ssh] 172.31.21.69:22: gathering host facts
INFO [ssh] 172.31.21.69:22: is running mirantis container runtime version 20.10.15
INFO [ssh] 172.31.21.69:22: detected private interface 'eth0'
INFO [ssh] 172.31.21.69:22: using 172.31.21.69 as private IP
INFO [ssh] 172.31.21.69:22: is running "Ubuntu 18.04.5 LTS"
INFO [ssh] 172.31.21.69:22: internal address: 172.31.21.69
INFO [ssh] 172.31.21.69:22: gathered all facts
INFO [ssh] 172.31.21.69:22: MKE has version 3.6.1
INFO ==> Running phase: Validate Hosts
INFO validating hostname uniqueness
INFO ==> Running phase: Download Client Bundle
INFO Successfully wrote client bundle to /home/user/.mirantis-launchpad/cluster/my-mke-cluster/bundle/admin
INFO ==> Running phase: Close Connection
INFO [ssh] 172.31.21.69:22: disconnected

The files for your user (i.e., ‘admin’ in this case) will be in the indicated directory. Retrieve the kube.yml file (e.g., for use with Lens). There’s also a helper script called env.sh in the directory, that can be used to immediately configure your shell to run kubectl (assuming you have it installed) against your new Mirantis Kubernetes Engine cluster:

eval "$(<env.sh)"

Step 8: Connect to your Mirantis Kubernetes Engine cluster using Lens

If you’d prefer to use Lens to access Kubernetes from your bootstrap machine, you may wish to switch to our Lens – Kubernetes IDE tutorial to install it. The basic steps are simple:

1. Start Lens

2. Click the “+” icon on the left to configure access for a new cluster.

   

3. Navigate to your kube.yml in the above directory and click, then click Add Cluster.

   

4. And proceed to interact with your cluster.

   

   
   

Note: If you need to tear down your cluster

If you need to dismantle your cluster, return to your /home/user/mirantis directory (where you stored your launchpad.yaml file) and enter:

./launchpad reset

Launchpad will kill running containers and uninstall everything. You can, of course, also simply terminate the virtual machines.

Step 9: Next steps

An interesting next step might be to redeploy your cluster with a second worker node (three nodes total) and use this node to install Mirantis Secure Registry, creating a complete system for Docker/Kubernetes development.