Run Docker and Kubernetes on MacBook: Simplified

In the tech environment, experimenting with new technologies can be both fun and a great way to enhance your ever-evolving skill set. When it comes to DevOps, understanding Docker and Kubernetes is essential. Setting up Docker and Kubernetes on your MacBook can significantly improve your development environment. This tech concept, explores Docker Desktop, which simplifies the installation and management of Docker and Kubernetes, allowing you to seamlessly containerize and deploy applications. Here’s a step-by-step guide to help you get started.

Step-by-Step Guide

1. Install Docker Desktop

Docker Desktop is a straightforward application for your Mac that includes Docker Engine, Docker CLI, Docker Compose, and Kubernetes.

Download Docker Desktop

Visit the Docker Desktop download page.
Download the .dmg file.

Install Docker Desktop

Open the downloaded .dmg file.
Drag the Docker icon to your Applications folder.
Open Docker from your Applications folder.

Setup Docker Desktop

Follow the on-screen instructions to complete the setup.
You may need to enter your password to allow Docker Desktop to install its components.

Verify Docker Installation

Open a terminal and run:

  docker --version

This should output the installed Docker version.

2. Enable Kubernetes in Docker Desktop

Docker Desktop includes a Kubernetes cluster that you can enable with just a few clicks.

Open Docker Desktop Preferences

Click the Docker icon in your menu bar and select “Preferences.”

Enable Kubernetes

Go to the “Kubernetes” tab.
Check the “Enable Kubernetes” checkbox.
Click “Apply & Restart.”

Verify Kubernetes Installation

Open a terminal and run:

  kubectl version --client

This should output the installed kubectl version.

3. Configure Docker and Kubernetes

With Docker and Kubernetes installed and running, you can configure them for your projects.

Docker Configuration

Docker Desktop automatically configures the Docker daemon.
Customize settings in Docker Desktop Preferences under the “Docker Engine” tab.

Kubernetes Configuration

Kubernetes configuration is managed via kubectl and the Kubernetes context.
Docker Desktop sets the context to use the built-in Kubernetes cluster.

4. Create and Deploy a Simple Application

To ensure everything is working correctly, let’s create a simple node.js application, containerize it with Docker, and deploy it on Kubernetes.

Create a Simple Node.js Application

Create a new directory for your project:

  mkdir next_struggle_app
  cd next_struggle_app

Initialize a new Node.js project:

  npm init -y
  npm install express

Create an index.js file:

  // index.js
  const express = require('express');
  const app = express();
  const port = 3000;

  app.get('/', (req, res) => {
    res.send('Hello, world! NextStruggle App');
  });

  app.listen(port, () => {
    console.log(`NextStruggle App running on port ${port}`);
  });

Create a Dockerfile

In the same directory, create a Dockerfile:

  # Use an official Node.js runtime as a parent image
  FROM node:14

  # Set the working directory in the container
  WORKDIR /usr/src/app

  # Copy package.json and package-lock.json
  COPY package*.json ./

  # Install dependencies
  RUN npm install

  # Copy the rest of the application code
  COPY . .

  # Expose the port the app runs on
  EXPOSE 3000

  # Run the application
  CMD ["node", "index.js"]

Build and Run the Docker Image

Build the Docker image:

  docker build -t next_struggle_app .

Run the Docker container:

  docker run -p 3000:3000 next_struggle_app

Your application should now be accessible at http://localhost:3000.

Create Kubernetes Deployment and Service Files

Create a directory for your Kubernetes configurations:

  mkdir k8s
  cd k8s

Create a deployment.yaml file:

  # deployment.yaml
  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: next-struggle-app
  spec:
    replicas: 3
    selector:
      matchLabels:
        app: next-struggle-app
    template:
      metadata:
        labels:
          app: next-struggle-app
      spec:
        containers:
        - name: next-struggle-app
          image: next_struggle_app:latest
          ports:
          - containerPort: 3000

Create a service.yaml file:

  # service.yaml
  apiVersion: v1
  kind: Service
  metadata:
    name: next-struggle-app
  spec:
    selector:
      app: next-struggle-app
    ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
    type: LoadBalancer

Apply Kubernetes Configurations

Apply the deployment and service configurations to your Kubernetes cluster:

  kubectl apply -f deployment.yaml
  kubectl apply -f service.yaml

Verify the Deployment

Check the status of your pods:

  kubectl get pods

Get the service details to find the external IP (if using LoadBalancer type):

  kubectl get services

Your application should be accessible at the external IP address of the service.

My Tech Advice: As a seasoned tech advisor and entrepreneur, I’ve been using a Mac for nearly a decade and have found the macOS terminal to be an excellent development tool that matches the capabilities of the Linux terminal. By following these steps, you can set up Docker and Kubernetes on your MacBook Pro, containerize your application with Docker, and deploy it on a Kubernetes cluster. This setup provides a robust environment for developing, testing, and deploying your applications. Happy coding!
#AskDushyant

#Docker #Kubernetes #DevOps #MacBook #Containerization #TechSetup #DevelopmentEnvironment