Elixir, Kubernetes, and Minikube - Miguel Cobá - Elixir Meetup #5

Miguel Cobá presented an engaging session on deploying Elixir applications using Kubernetes and Minikube. Miguel shared his expertise on setting up a local Kubernetes cluster, deploying an Elixir application, and scaling it seamlessly.

About Miguel Cobá

Miguel Cobá is a software developer based in Barcelona, with experience in Elixir and Elm. He has authored two books on Elixir and is passionate about sharing his knowledge through writing and speaking.

Why Use Kubernetes and Minikube?

The Power of Kubernetes

Kubernetes is an open-source platform designed to automate the deployment, scaling, and management of containerized applications. It enables efficient management of application workloads and services.

Key Benefits:

• Automation: Automate deployment, scaling, and operations.
• Scalability: Easily scale applications to handle increased load.
• Management: Manage containerized applications efficiently.

Introduction to Minikube

What is Minikube?

Minikube allows you to run Kubernetes locally. It is a tool that enables developers to create and manage a local Kubernetes cluster on their personal computers.

Key Features:

• Local Kubernetes: Run a local Kubernetes cluster for development.
• Easy Setup: Simple installation and setup process.
• Learning Platform: Ideal for learning and development purposes.

Setting Up Minikube

Installing Minikube

Miguel demonstrated the process of installing Minikube on a Mac using Homebrew. He highlighted the ease of installation and setup, which makes Minikube an excellent tool for developers new to Kubernetes.

Steps:

1. Install Homebrew: If not already installed, install Homebrew.
2. Install Minikube: Use the command brew install minikube to install Minikube.
3. Start Minikube: Initialize the Minikube cluster using minikube start.

Deploying an Elixir Application

Creating the Elixir Application

Miguel created a simple Elixir application named "Curiosum Meetup" and set up the necessary dependencies. He used the Phoenix framework to generate the application structure.

Steps:

1. Generate Phoenix App: Use mix phx.new to create a new Phoenix application.
2. Install Dependencies: Run mix deps.get to install dependencies.

Dockerizing the Application

To deploy the application on Kubernetes, Miguel demonstrated how to create a Docker image of the Elixir application. He used the Phoenix release feature to generate a Dockerfile and build the image.

Key Points:

• Generate Dockerfile: Use mix release.init to create a Dockerfile.
• Build Image: Use Docker commands to build the image and push it to Docker Hub.

Deploying to Kubernetes

Creating Kubernetes Resources

Miguel explained the essential Kubernetes resources needed for deployment, including services and pods. He provided a step-by-step guide on creating these resources using configuration files.

Key Resources:

• Headless Service: Used for internal communication within the cluster.
• Deployment: Defines the application pods and scaling requirements.

Applying the Configuration

Using the kubectl command-line tool, Miguel applied the configuration files to create the Kubernetes resources and deploy the application.

Steps:

1. Apply Configuration: Use kubectl apply -f to apply configuration files.
2. Check Status: Use kubectl get pods to check the status of the pods.

Scaling the Application

Scaling Pods

Miguel demonstrated how to scale the application by increasing the number of pods. He explained the benefits of scaling and how Kubernetes handles the process efficiently.

Key Points:

• Replica Sets: Define the desired number of pod replicas.
• Scaling Command: Use kubectl scale to adjust the number of replicas.

Practical Tips and Q&A

Practical Tips

Miguel shared practical tips for managing Kubernetes deployments, including handling environment variables, managing secrets, and ensuring secure configurations.

Key Tips:

• Environment Variables: Use Kubernetes secrets for sensitive information.
• Secure Configurations: Ensure secure access to Kubernetes resources.

Q&A Highlights

During the Q&A session, Miguel addressed questions on Elixir’s distributed nature, handling network partitions, and using Kubernetes strategies for managing clusters. He provided insightful answers and encouraged attendees to explore further.

Key Questions:

• Distributed Elixir: How Elixir nodes communicate in a cluster.
• Network Partitions: Strategies for managing globally unique processes.
• Scaling Strategies: Using Kubernetes for efficient scaling.

Conclusion

Miguel Cobá’s presentation at Elixir Meetup #5 offered a comprehensive guide to deploying Elixir applications using Kubernetes and Minikube. By following his step-by-step approach, developers can leverage these powerful tools to manage and scale their applications efficiently.

Join the Community

Ready to deploy your Elixir applications with Kubernetes? Register for the next Elixir Meetup at Curiosum Meetups: Registration Join our community of Elixir enthusiasts at Elixir LinkedIn Group Prefer watching the presentation? Here’s the video