Nilesh Gule's Technical Blog

LM Studio: A Comprehensive Guide to Experimenting with Large Language Models Locally

noreply@blogger.com (Nilesh Gule) — Sat, 12 Oct 2024 23:18:00 +0000

Introduction: Running LLMs Locally with LM Studio

In the realm of artificial intelligence, large language models (LLMs) have emerged as powerful tools capable of generating human-quality text, translating languages, writing different kinds of creative content, and answering your questions in an informative way. If you're looking for a desktop-based application to work with and experiment with LLMs, LM Studio is a great option.

Running large language models (LLMs) locally is gaining popularity for security reasons and experimentation. This guide complements a YouTube video that demonstrates how to set up LM Studio for this purpose.

What is LM Studio?

LM Studio is a cross-platform desktop application that allows you to search for, instantiate, and experiment with various LLMs. It provides a user-friendly interface and offers a range of features to cater to both beginners and advanced users.

Getting Started with LM Studio on macOS

The video highlights the ease of installing LM Studio using Homebrew, a popular package manager for macOS. Here's how to get started:

Install Homebrew (if not already installed): Follow the instructions in this video (link: https://youtu.be/p-YKv6TfcqI)
Install LM Studio: Open a terminal window and run the following command:

Bash
brew install lmstudio

Exploring LM Studio's User Interface

LM Studio boasts a user-friendly interface that allows you to:

Search for and download LLMs from the Hugging Face repository (link: https://huggingface.co/)
Load downloaded models for interaction
Customize the model's output using various parameters

Key Features of LM Studio

User Interface:
- LM Studio presents a ChatGPT-like interface, making it easy to interact with different models.
- The interface includes options to discover models, load them locally, and interact with them using a chat-based format.
Model Discovery and Selection:
- The "Discover" section allows you to explore a variety of LLMs from the Hugging Face repository.
- You can search for models based on specific criteria and view their details, including the number of parameters, architecture, and author.
Model Loading and Experimentation:
- Once you've selected a model, you can download and load it locally.
- The application provides a convenient way to switch between different models and experiment with their capabilities.
System Prompts and Customization:
- You can define system prompts to influence the output of the models.
- Customize other parameters such as the length of the response, stop strings, and more.
Model Runtimes:
- LM Studio supports various runtimes that can enhance the performance of the models.
- The application provides information on compatible runtimes and allows you to download and install them.
Developer Mode:
- For advanced users, the developer mode offers additional features and settings.
- Explore options like server configuration, API endpoints, and logging.

Using System Prompts with Mr. Bean

Defining a System Prompt: A system prompt provides instructions or context to the model. In this case, we defined a system prompt indicating that the model should respond as if it were Mr. Bean.
Experimenting with Different Models: We tested the system prompt with each model to see how they interpreted and applied the prompt.
Observations:
- Meta Llama: Successfully incorporated the Mr. Bean persona into its responses, providing humorous and unexpected answers.
- Phi: While it seemed to understand the prompt, its responses were less humorous and more straightforward.
- Mistral: Had limitations in using system prompts, and its responses were not as aligned with the Mr. Bean persona.

Additional Resources

LM Studio Homepage: https://lmstudio.ai/
LM Studio System Requirements: https://lmstudio.ai/docs/system-requirements

This enhanced guide, along with the linked video by Nilesh Gule, provides a comprehensive introduction to using LM Studio for experimenting with LLMs locally.

Bonus: The video description includes links to additional resources related to LLMs and software installation tools (Chocolatey for Windows).

Install Visual Studio Code on Your Mac with Brew: A Step-by-Step Guide

noreply@blogger.com (Nilesh Gule) — Sat, 28 Sep 2024 22:54:00 +0000

Background

I've been using Visual Studio Code (VS Code) for a few years now, and I've got to say, it's been an absolute game-changer for my development workflow. For those of you who are new to VS Code, it's a lightweight yet powerful code editor that's perfect for developers of all levels.

One of the things I love about VS Code is its flexibility. You can customize it to fit your specific needs with a wide range of extensions. Whether you need a linter, a debugger, or a Git integration, there's probably an extension for it.

Today, I'm going to walk you through how to install VS Code on your Mac using Homebrew commonly known as Brew, a package manager that makes it super easy to install and manage software on macOS.

Why Choose VS Code?

Before we delve into the installation, let's explore what makes VS Code a developer favourite:

Lightweight Powerhouse: Unlike bulky IDEs (Integrated Development Environments), VS Code is a streamlined application that won't bog down your system. This is ideal for older machines or developers who prioritize a clean workspace.
Extension Extravaganza: VS Code's core functionality is supercharged by a vast library of extensions. These extensions offer features like code completion (Intellisense), debugging tools, language support for various programming languages, and more. Essentially, you can tailor VS Code to precisely fit your development needs.
Focus on the Essentials: By leveraging extensions, VS Code lets you maintain a clutter-free environment. Install only the extensions you need for your current project, eliminating unnecessary features that might bloat a traditional IDE.
Git Integration Nirvana: VS Code seamlessly integrates with Git, a popular version control system. This allows developers to manage code versions, track changes, and collaborate with others directly within the VS Code interface.

Getting Started with Homebrew:

This tutorial utilizes Homebrew, a fantastic package manager for macOS. Brew simplifies software installation and management, making it a developer's must-have tool.

What We'll Cover:

Introduction to VS Code: We'll briefly introduce you to VS Code and its developer benefits.
Installing Brew (if needed): Don't have Brew yet? We'll guide you through its installation process.
VS Code Installation with Brew: We'll demonstrate the straightforward steps to install VS Code using a simple Brew command.
Getting Started with VS Code: We'll show you how to open and use VS Code for the first time.

By the end of this tutorial, you'll have a fully functional VS Code installation on your Mac, ready to elevate your development experience.

Let's Get Coding!

Step 1: Install Brew

If you don't already have Brew installed, you can do so by following the instructions on their website: https://brew.sh/

Step 2: Install VS Code

Once you have Brew installed, open your terminal and type the following command:

Bash
brew install visual-studio-code
This will download and install VS Code for you.

Step 3: Get Started

Once VS Code is installed, you can launch it by typing code in your terminal.

Why Use Brew?

Using Brew to install VS Code has several advantages:

Easy updates: Brew will automatically update VS Code to the latest version when it becomes available.
Dependency management: Brew will also handle any dependencies that VS Code might have, so you don't have to worry about installing them manually.
Consistent installation: Using Brew ensures that VS Code is installed in a consistent way across all of your Mac devices.

Bonus Tips and Resources:

Visual Appeal: VS Code boasts a clean and customizable interface. You can tailor it to your preferences for a truly personalized development environment.
Thriving Community: A robust developer community surrounds VS Code. This translates to a wealth of online resources, tutorials, and forums for troubleshooting and learning new features.

Feeling Inspired? Let's Connect!

If you found this tutorial helpful, give it a thumbs up and subscribe to our channel for more tech tutorials! Don't forget to hit the notification bell to stay updated. Feel free to leave any questions or suggestions in the comments below. Thanks for watching, and happy coding with Visual Studio Code on your Mac! Until next time, Code with Passion and Strive for Excellence!

Additional Resources:

Visual Studio Code - https://code.visualstudio.com/
Homebrew - https://brew.sh/

Connect with me:

Subscribe: https://www.youtube.com/watch?v=Xn6fEc74yBw
YouTube: https://www.youtube.com/watch?v=Xn6fEc74yBw
GitHub: https://github.com/NileshGule
Twitter: https://twitter.com/nileshgule/status/1433313237873815559?lang=en
Website: https://handsonarchitects.com/
LinkedIn: https://au.linkedin.com/in/nileshgule

Unleashing the Power of LLMs: A User-Friendly Approach with Open Web UI

noreply@blogger.com (Nilesh Gule) — Thu, 26 Sep 2024 21:24:00 +0000

Background

Tired of the complexities of using terminal commands to interact with large language models (LLMs)? There's a simpler, more intuitive way. This post dives into the power of Open Web UI, a user-friendly interface for interacting with offline LLMs running on your computer, inspired by the familiar ChatGPT interface.

The Magic of Offline LLMs and Open Web UI

Imagine interacting with multiple LLMs like Llama 3.1, Mistral, and Phi3 simultaneously, all running offline on your machine! The YouTube video showcases how to achieve this with Ollama, a platform for running LLMs locally. Open Web UI takes this a step further by providing a user-friendly interface on top of Ollama, all managed through Docker.

Getting Started: A One-Command Solution

The YouTube video demonstrates a convenient one-line Docker command to run Open Web UI:

docker run --detach \
--publish 3000:8080 \
--add-host=host.docker.internal:host-gateway \
--volume open-webui:/app/backend/data \
--name open-webui \
--restart always \
ghcr.io/open-webui/openwebui:main

This command downloads the Open Web UI image, sets it up with specific configurations, and runs it in the background.

Dive Deeper: Resources for Further Exploration

Nilesh Gule's YouTube channel offers a wealth of resources for exploring LLMs and Open Web UI:

Open Web UI and k8sGPT Tutorials:
- How to use k8sGPT
- Setting up Llama 3.1 as the backend provider for k8sGPT
- k8sGPT and Hindi translation using Llama 3.1

Unlocking the Power of Multiple LLMs

Once you launch Open Web UI, you can seamlessly switch between different offline LLMs, including Llama 3.1, Phi3, and Mistral. This allows you to experiment with each model's unique capabilities and find the perfect fit for your needs.

Shaping the LLM's Response: System Prompts and Parameters

Open Web UI goes beyond just providing a chat interface. You can also influence the LLM's output using system prompts and various parameters. Here's how:

System Prompts: The video demonstrates how to add a "character" to your prompts. For instance, you can use Albert Einstein as a system prompt to query about Melbourne weather, receiving a response that reflects his scientific perspective. This injects personality and context into the LLM's responses.
Parameters: Fine-tune the LLM's output with settings like temperature, top_p, and frequency_penalty. These settings control aspects like creativity, randomness, and repetitiveness in the generated text.

Additional Resources:

OpenWeb UI homepage: https://openwebui.com/
OpenWeb UI documentation: https://docs.openwebui.com/

Connect with Nilesh Gule:

Subscribe to his YouTube channel
Follow him on social media and his website for more insights on LLMs: The links are provided in the description section of this blog post.

By combining the power of offline LLMs with the user-friendly interface of Open Web UI, you can unlock a world of creative possibilities. Explore different models, experiment with prompts, and customize the output to achieve your desired results. Happy experimenting!

How to store Terraform State in Azure Storage Account

noreply@blogger.com (Nilesh Gule) — Fri, 20 Sep 2024 03:00:00 +0000

This blog post, based on a YouTube video tutorial, explores how to store Terraform state in a remote Azure storage account.

Why Store Terraform State Remotely?

Local storage creates issues when working in a team.
Two team members modifying the same state file can lead to conflicts.
Local storage deletion can cause problems.

Benefits of Remote Storage:

Centralized location accessible by all team members.
Improved collaboration and state management.

How to Store Terraform State in Azure Storage

Prerequisites:
- Azure subscription
- Azure storage account
- Terraform installed
Configure Backend with Terraform:
- Create a backend.tf file.
- Specify the storage account details:
  - Resource group name
  - Storage account name
  - Container name
  - Key (optional)
Set Access Key as Environment Variable:
- Use Azure CLI to retrieve the storage account access key.
- Set the key as an environment variable for Terraform to access the storage account.
Initialize Terraform:
- Run terraform init to initialize Terraform with the remote backend configuration.
Manage Your Resources:
- Use terraform plan and terraform apply to plan and apply infrastructure changes.
- The state file is created and stored in the Azure storage container.

Verifying Remote Storage:

Access the Azure storage account container.
The container should contain a terraform.tfstate file representing the Terraform state.

Key Points:

Remote storage ensures state locking and consistency.
Consider using Azure Key Vault for secure storage and access control of the storage account key.

Call to Action:

Subscribe to Nilesh Gule's channel (https://youtube.com/@nilesh-gule) for more Terraform tutorials.

Leave comments suggesting future video topics.

Additional Resources

Terraform: https://developer.hashicorp.com/terraform
Terraform official provider for Azure: https://registry.terraform.io/providers/hashicorp/azurerm/latest
Terraform documentation for Azure Resource Group Module: https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/resources/resource_group
YouTube video on how to install Terraform using Homebrew: https://m.youtube.com/watch?v=oURFbTZLMl0
YouTube video on how to provision Azure Resource Group using Terraform: https://www.youtube.com/watch?v=wsibSX00ylM
YouTube video on how to cross reference resources in Terraform: https://m.youtube.com/watch?v=Fs7Bm0cqMsA
YouTube video on how to manage variables in Terraform: https://www.youtube.com/watch?v=oArutYYvQ_Y
Github repository with the source code: https://github.com/NileshGule
Terraform videos playlist: https://m.youtube.com/playlist?list=OLAK5uy_lSeauTc6VKEW9XNFLAHaYIC7U01rWJ2Q

Run Generative AI models on your Laptop with Ollama

noreply@blogger.com (Nilesh Gule) — Thu, 19 Sep 2024 21:49:00 +0000

Since OpenAI released ChatGPT, there's been a surge of interest in generative AI (GenAI). These powerful models can write different kinds of creative text formats, translate languages, write different kinds of creative content, and answer your questions in an informative way. However using them often requires cloud access, which can raise security or privacy concerns.

This blog post explores how to run GenAI models locally on your machine using Ollama, an open-source platform from Meta.

What is Ollama?

Ollama is a user-friendly platform that allows you to download and run various large language models (LLMs) on your workstation. These models include Llama 3.1, Phi, Minstrel, and Gemma.

Why Run GenAI Models Locally?

There are several reasons why you might want to run GenAI models locally:

Security: If you're working with sensitive data, you might prefer not to upload it to the cloud.
Privacy: You might be concerned about your data being accessed by third parties.
Cost: Running models locally can be more cost-effective than using cloud-based services.
Offline Use: You can use GenAI models even without an internet connection.

Getting Started with Ollama

Here's a step-by-step guide to get started with Ollama:

Head over to Ollama's website: https://ollama.com/library
Choose your model: The website showcases various models with details like parameters and template used for invoking them. Select a model that suits your needs.
Check resource requirements: Make sure your computer meets the minimum RAM requirements for the chosen model.
Install Ollama: You can install Ollama using either the command line (package manager) or the downloadable user interface (GUI).
Download the model: Ollama can download the model for you if it's not already on your machine.
Start the Ollama service: Use the Ollama serve command to run the service in the background.
Run the model: Use the Ollama run command followed by the model name (e.g., Ollama run Llama3.1).
Interact with the model: Once the model is running, you can start feeding it prompts and receive its responses.

Following Along with the Video Tutorial

It's helpful to watch the video alongside this blog post for a more visual understanding.

Key Takeaways

Ollama offers a convenient way to experiment with GenAI models on your local machine. By following these steps and considering the resource requirements, you can unlock the potential of generative AI for your projects without relying on cloud services.

Dependabot - Update Project dependencies automatically

noreply@blogger.com (Nilesh Gule) — Mon, 02 Jan 2023 05:27:00 +0000

Background

Maintaining project dependencies can be a difficult task, especially for larger projects with many dependencies. It is important to keep track of which dependencies are being used and which versions are compatible with the project. However, this can become a challenge as new versions of dependencies are released and there may be conflicts with existing code. Additionally, it can be time-consuming to resolve these conflicts and update the dependencies, which can impact the overall development timeline of the project. It is important to have a clear strategy in place for managing dependencies to avoid these issues. In this post, we will see how to use Dependabot to automatically update dependencies for project hosted in a GitHub repository.

What is Dependabot?

Dependabot is a tool that automatically detects and fixes vulnerabilities in a project's dependencies. It works by regularly checking for updates to the dependencies in a project and submitting pull requests with the updated dependencies when they are available. This can help reduce the risk of security vulnerabilities in a project and save developers time by automating the process of updating dependencies. Dependabot supports a variety of languages and package managers, including npm, pip, Maven, and Gradle.

It does this by regularly checking for new versions of dependencies and alerting developers to any vulnerabilities. Dependabot supports two modes of operation: security updates and version updates.

Security updates mode: In this mode, Dependabot monitors dependencies for known vulnerabilities and submits pull requests to update to a secure version when a vulnerability is detected. This helps developers ensure that their project is using secure dependencies and reduces the risk of security breaches.

Version updates mode: In this mode, Dependabot checks for new versions of dependencies and submits pull requests to update to the latest version when it is available. This can help developers take advantage of bug fixes and performance improvements in the latest versions of dependencies.

By using Dependabot, developers can automate the process of keeping their dependencies up-to-date and secure, saving time and effort.

Enable Dependabot for GitHub repository

In order to configure Dependabot for a GitHub repository, go to the settings for the Github repository which needs to be integrated with Dependabot. Under the code security and analysis section, there are multiple configurations related to Dependabot as shown below

We can configure alerts, Security Updates and Version Updates separately.

Alternatively, you can also configure Dependabot by adding a .github/dependabot.yml file to your repository and specifying the desired configuration in the file. For more information on this method of configuration, see the Dependabot documentation.

Configure Package ecosystem

In the dependabot.yml file we need to configure the package ecosystem. This helps Dependabot to monitor the packages for any updates to the dependencies. Within the same project it is possible that there are more than one package manager used to manage dependencies like Node Package Manager (NPM) for Node package and Maven or Gradle for Java packages used for backend processing.

In the file, specify the package ecosystems that you want Dependabot to monitor under the package_ecosystems key. By configuring the package ecosystem setting for Dependabot, you can specify which package managers and package ecosystems Dependabot should monitor for updates. This can help ensure that Dependabot is monitoring the dependencies that are relevant to your project.

YouTube video demonstrating Dependabot usage

Check out this YouTube video which explains in detail how to configure the Dependabot for a GitHub repository.

Dependabot Pull Request for updated dependencies

When Dependabot detects that an update is available for a dependency in your project, it will create a pull request with the updated dependency. This pull request will contain a summary of the changes being proposed, including the current and new versions of the dependency, and a list of the files that will be modified.

It is up to the repository maintainer to review the pull request and decide whether to merge it. If the pull request is accepted, the updated dependency will be included in the project. If there are any conflicts with existing code, Dependabot will attempt to resolve them automatically, but in some cases, manual resolution may be required.

Creating pull requests for updated dependencies helps ensure that projects are using the most up-to-date and secure versions of their dependencies. It also allows for an easy way for repository maintainers to review and control changes to the dependencies in their project.

Below screenshots show different details reported in the Pull Request created by Dependabot for every dependency that is outdated in the project.

Summary of changes showing Release notes, Changelog, Commits, Compatibility issues and also commands and options.

Release notes

Changelog

Commits

Commands and Options

Advantages of using Dependabot to automatically update dependencies

There are several advantages to using Dependabot to automatically update dependencies:

Improved security: By regularly updating dependencies, Dependabot helps reduce the risk of security vulnerabilities in a project. It monitors dependencies for known vulnerabilities and submits pull requests to update to a secure version when a vulnerability is detected.

Improved stability: New versions of dependencies can often include bug fixes and performance improvements. By using Dependabot to update dependencies, developers can ensure that their project is using the most stable versions available.

Improved efficiency: Updating dependencies can be a time-consuming task, especially for larger projects with many dependencies. By automating the process with Dependabot, developers can save time and effort and focus on other tasks.

Improved control: Dependabot creates pull requests for updated dependencies, allowing repository maintainers to review and control changes to the dependencies in their project. This can help ensure that updates are thoroughly tested and do not cause conflicts with existing code.

Conclusion

Overall, Dependabot is a useful tool for developers to keep their project dependencies up-to-date and secure. By automating the process of updating dependencies, Dependabot helps developers improve the security, stability, efficiency, and control of their projects. It is a valuable resource for repository maintainers to ensure that their project is using the most recent and secure versions of dependencies and to easily review and control changes to those dependencies. As such, it is a tool that developers should consider using in their projects.

Until next time, Code with Passion and Strive for Excellence.

Scan OpenSource libraries free with Mend

noreply@blogger.com (Nilesh Gule) — Mon, 02 Jan 2023 04:27:00 +0000

Background

Using free and open-source libraries can foster innovation in a number of ways. For one, it allows developers to easily incorporate pre-existing code into their projects, saving them time and effort that they can then redirect towards developing new features and functionality. Additionally, the open-source model promotes collaboration and sharing, which can lead to the creation of more powerful and sophisticated libraries as developers from around the world contribute their skills and knowledge. Finally, open-source libraries often have large and active communities of users and developers, which can provide valuable support, inspiration, and feedback for those looking to push the boundaries of innovation.

There are a few potential risks to be aware of when using open source libraries. One risk is the potential for vulnerabilities or security issues in the library code. It's important to regularly check for and update to the latest versions of the library to minimize this risk. We will see how to use Mend to scan open-source libraries for free. It integrates with GitHub making it very easy for developers to get real-time updates related to the open source dependencies.

Quick overview of Mend

Mend is an open source library management platform that helps developers identify, track, and secure the open source libraries used in their projects. It provides real-time alerts for any potential security vulnerabilities or license compliance issues, and offers integration with a variety of tools such as GitHub and Azure DevOps. With Mend, developers can easily see the open source libraries they are using and ensure that they are up to date and secure, reducing the risks associated with using open source software. Mend is the next version of WhiteSource Bolt, and aims to provide a simple and effective way for developers to manage their open source dependencies.

Integrate Mend with GitHub

Mend helps developers get real-time security alerts and compliance issues on open source dependencies within GitHub. Once Mend is configured to a GitHub repository, it will continuously scan the codebase and identify any open source libraries that are being used. It will then check for any known vulnerabilities or license compliance issues associated with those libraries, and provide alerts to the developers through the GitHub interface. Apart from notifications within the GitHub interface, Mend is configured to automatically create issues related to the vulnerabilities.

This allows developers to quickly and easily see any potential issues with the open source dependencies they are using, and take steps to address them. Mend is configured to automatically open issues with suggested fixes for any identified vulnerabilities, streamlining the process of addressing them.

Enable Mend Bolt for GitHub

It is very easy to integrate Mend with GitHub. There is a GitHub application available named Mend Bolt for GitHub. We can configure it for all the repositories under a GitHub organisation or selectively configure Mend for individual repositories.

YouTube video showing Mend configuration and usage

Refer to the YouTube video which explains in detail the different steps required for configuring Mend for a GitHub repository.

Details shown in Mend issue related to vulnerabilities

For each of the vulnerabilities reported by mend, it provides detailed information with a summary, CVE information, transitive dependencies and recommended fixes if any. The screenshots below show these different characteristics of the Mend issue

How to fix vulnerabilities reported by Mend

If you have received a report of vulnerabilities from Mend, it is important to address them as soon as possible in order to secure your system and prevent potential attacks. The first step is to carefully review the report and understand the nature of the vulnerabilities and the potential risks they pose. Next, you should determine the best course of action to fix the vulnerabilities. It is also a good idea to test the fixes to ensure that they effectively address the vulnerabilities and do not cause any unintended issues. It is important to keep in mind that vulnerabilities can be exploited quickly, so it is crucial to prioritize and address them in a timely manner.

In the YouTube video above, I showed how to fix the reported vulnerability by upgrading the dependency version to a higher version with a fix. This is a manual step. In another video, I took this a step further and used another open source tool which integrates with GitHub named Dependabot to automatically update the outdated dependencies. Check out this video if you are interested to know more about it.

Advantages of using Mend

Mend helps organizations identify and address vulnerabilities in their systems. Some of the advantages of using Mend include:

Improved security: By regularly scanning for vulnerabilities, Mend can help organizations identify and fix potential security weaknesses before they can be exploited by attackers.

Risk management: Mend can help organizations prioritize vulnerabilities based on their severity and the potential risks they pose, allowing them to focus their efforts on the most critical issues first.

Compliance: Many organizations are required to meet certain security standards in order to comply with regulations or industry standards. By using Mend, organizations can ensure that their systems are in compliance with these requirements.

Time and cost savings: Fixing vulnerabilities can be time-consuming and costly, especially if they are discovered after an attack has occurred. By using Mend to proactively identify and address vulnerabilities, organizations can save time and resources that would otherwise be spent on remediation.

Conclusion

Mend can help organizations improve their security posture and mitigate the risk of cyber attacks by identifying and fixing vulnerabilities in a timely and cost-effective manner. Cyber attacks are becoming more sophisticated and frequent, and it is important to have tools in place to protect yourself and your organization from these threats. Mend is a powerful tool that can help you identify and address vulnerabilities in your systems before they can be exploited by attackers. By using Mend, you can improve your security posture, mitigate the risk of cyber attacks, and save time and resources that would otherwise be spent on remediation. Protecting your systems and data is crucial in today's digital world, and Mend is an excellent tool to help you do so.

Until next time, Code with Passion and Strive for Excellence.

Code faster with AI using tabnine

noreply@blogger.com (Nilesh Gule) — Tue, 01 Nov 2022 02:28:00 +0000

Background

Artificial Intelligence (AI) is getting infused into every sphere of our life. We find AI-powered smartphone cameras, devices, and voice assistants like Cortana, Alexa, Bixby, and various other alternatives. AI and Machine Learning (ML) is used to predict thing based on past patterns. In every industry, there are use cases related to AI and ML which can help improve people's lives in one way or the others.

One such area which is of keen interest is software developers. There are various studies done across the globe to improve developer productivity. Software developers spend a lot of time writing code and looking for information over the internet. We use things like code editors such as Notepad++, Sublime, Visual Studio Code, a full-blown integrated development environment such as Visual Studio Code, IntelliJ, PyCharm, Goland, Eclipse, Rider, etc., database connectivity tools, and many other things to get our work done. This involves context-switching between different tools depending on the type of application and the programming language or backend databases used for the application development.

AI-powered assistant for developers

Many of the code snippets that we write are following a specific pattern. Some of the common examples are listed below

Query database table and fetch top 100 Orders, sort by highest order value
Perform sentiment analysis on a tweet / social media post
Make an API call to query some data
Write a function to find the average size of the basket from a given carts

These are just a few examples. But you can get a sense of the pattern that is being used. What varies is the programming language used and the syntax of the language. Nowadays it is possible to use Natural Language Processing (NLP) to specify the intent of what the code intends to do and let AI generate the code.

One such tool I came across is called tabnine. The tagline for tabnine says that it is an AI assistant for software developers. It helps developers to write code faster. It has two modes of operation. First is the single line mode where it recommends code for one single line. Ans second is the whole function code.

It integrates with the most common Integrated Development Environments (IDE) and supports most of modern-day programming languages and frameworks. The screenshots below list the IDEs and programming languages that it supports.

Refer to the install section to get the most updated list of IDEs and programming languages. If the language you are using or the IDE you are using is not on the list, most probably you are not working with a modern tech stack :)

My experience with Tabnine

I used Tabnine with my favorite code editor Visual Studio Code. I used it to generate C# code, document the project using Markdown files, and to write Powershell scripts. It was quite accurate in terms of its suggestions and recommendations with an accuracy rate of about 75-80%. It saved me quite a lot of time while writing the docs for a project.

Although Markdown and Powershell are not listed in the supported languages, tabnine did a fantastic job in terms of proving context-aware recommendations.

I shared my experience of using Tabnine in a YouTube video.

Summary / Conclusion

Personally, I found Tabnine very useful. It avoided the context switching for me to look for information. It helped me to generate code faster. Documenting the code or project with markdown files was a breeze saving me at least 70% of the typing efforts.

I think a tool like Tabnine can be very handy when we are learning a new programming language. It can help us quickly understand code syntax and best practices. The machine learning model used to train the assistant can scan different types of repositories within the organization as well as public repositories. This can help to implement best practices.

Hope you find this useful. I would love to hear about your experience.

Until next time, Code with Passion and Strive for Excellence.

Zero downtime deployment with Kubernetes using Rolling update Strategy

noreply@blogger.com (Nilesh Gule) — Wed, 12 Oct 2022 23:00:00 +0000

Background

Nowadays modern cloud-native applications are developed and deployed at a rapid scale and pace. The legacy techniques used for upgrading applications and services are no longer relevant. We want to give the best user experience to end users. One of the things which are gaining popularity and is already a mainstream technique is progressive delivery. This allows us to upgrade the application version in a progressive manner by reducing the blast radius. In this post, we will look at how to achieve zero downtime deployment using the Rolling Update strategy with Kubernetes.

Quick overview of the rolling update strategy

The rolling update strategy allows applications with multiple instances or replicas to upgrade from one version to another in a controlled manner. Instead of upgrading all the replicas together, this strategy applies changes in batches and replaces the older version with a new one. As a result of this, the application can continue to run with the reduced number of instances while the upgrade is progressing.

One of the pre-requisite for implementing a rolling update strategy is that the application needs to have multiple replicas or instances running. If there is only a single instance of the application, there will be a slight downtime. Kubernetes supports the rolling update strategy natively. We do not need any additional things to implement it with Kubernetes. When we use Kubernetes Deployment to deploy our pods, the rolling update is the default strategy.

If you have been using Kubernetes deployments, you would have unknowingly used the rolling update strategy when upgrading the application version.

Use the Rolling update strategy for zero downtime deployment

If we don't override any settings related to rolling updates, by default Kubernetes will apply 25% MaxSurge and 25% MaxUnavailable settings. What this means is that at the time of the upgrade maximum of 25% of the replicas will be added. Same way, when the old version of the replica is replaced with the new one, a maximum of 25% would be replaced at a time.

By doing this, it ensures that there are 80% of replicas in working condition during the upgrade process and the end users are not impacted. If we have exposed the deployment outside of the Kubernetes cluster using a Service, then the LoadBalancer will route the traffic accordingly between the new and older versions.

Youtube video demo

Refer to the YouTube video to see this in action.

Other alternatives to Rolling Update Strategy

There are other alternatives to the rolling update strategy. Modern-day cloud-native applications support advanced deployment strategies or techniques such as Blue-Green deployment or Canary deployment which also allow zero downtime deployment with progressive delivery. Refer to the links to watch YouTube videos on my channel to understand how these can be applied to your Kubernetes applications.

Conclusion

Gone are the days of bringing down servers and applications to upgrade them. With the cloud, we can easily upgrade applications and services with minimal impact on end users. Use modern techniques such as rolling update, Blue Green deployment or Canary deployment to achieve 100% availability for your application.

Until next time, Code with Passion and Strive for Excellence.

Cloud native Fifteen Factor Apps

noreply@blogger.com (Nilesh Gule) — Tue, 09 Aug 2022 11:02:00 +0000

Background

A few years back Heroku published a set of guidelines for building and deploying applications which became known as 12 Factor App. These are guiding principles for developing, operating and deploying Web apps or software-as-a-service (SaaS). Over a period of time, as cloud adoption increased and microservices became popular there are additional factors which got added. We also saw changes in the application integration space with more real-time processing gaining popularity. We now have event driven microservices which empower organisations to leverage data to get more value using event driven architecture.

15 Factor Apps series

In order to understand the 15 factors better, I am creating this series of YouTube videos. We will cover all the 15 factors in different parts. Below is the picture showing the initial 12 factors as described in the 12Factor.net and then we also have the next picture showing the additional 3 factors as part of the 15 factors.

Here is a list of 15 Factors which help to make the modern cloud-native applications highly scalable, resilient and portable:

Codebase - one codebase tracked in version control, many deploys
Dependencies - Explicitly declare and isolate dependencies
Config - store config in environment
Backing services - treat backing service as an attached resource
Build, release and run - strictly separate build and run phases
Processes - execute app as one or more stateless processes
Port binding - expose services via port binding
Concurrency - scale-out via process model
Disposability - maximize robustness with fast startup and graceful shutdown
Dev/Prod parity - keep development, staging and production as similar as possible
Logs - treat logs as stream of events
Admin processes - Run admin/management tasks as one-off process
API first - define service contract
Telemetry - monitor process performance
Authentication - secure applications across hardware, network and software layers

Youtube videos

Below is the list of videos covering each of these factors

You can read the ebook by Kevin Hoffman about the 15 Factor Apps named Beyond the Twelve-Factor App (oreilly.com).

Until next time, Code with Passion and Strive for Excellence.

Kubernetes Blue-Green Deployment

noreply@blogger.com (Nilesh Gule) — Tue, 08 Feb 2022 14:39:00 +0000

Blue-Green deployment is a strategy to achieve zero-downtime deployment. With cloud-native applications, it is common practice to reduce downtime when upgrading the application version. Due to the ease with which we can provision new infrastructure on the cloud, it becomes easier to adopt new ways of improving the deployment.

Blue Green deployment definition

In this post, we will look at how to use Blue-Green deployment with Kubernetes. One of the best places to look for definition is the glossary of terms provided by Cloud Native Computing Foundation (CNCF). The CNCF defines Blue Green deployment as

"A strategy for updating running computer systems with minimal downtime. The operator maintains two environments, dubbed “blue” and “green”. One serves production traffic (the version all users are currently using), whilst the other is updated. Once testing has concluded on the non-active (green) environment, production traffic is switched over (often via the use of a load balancer)."

The main point here is two identical environments named blue and green and the traffic switching using load balancer. Lets see how this can be applied to the Kubernetes environment.

How to perform Kubernetes Blue Green Deployment

We start by creating two versions of the application. Let's say V1 which is deployed to the live environment. This forms our Blue environment. To keep things simple, I have created a simple ASP.Net Core application. It is packaged into a Docker image with two tags. One tag has Blue background and will be used to deploy to the Blue environment. The other container image with green tag will be used to deploy to the Green environment. The two docker container images are published to Dockerhub as

nileshgule/blue-green-demo:blue
nileshgule/blue-green-demo:green

Step 1 : Setup Blue environment

Once the container images are pushed to the container registry, we can use Kubernetes Deployment to deploy to the Kubernetes cluster. We create a blue-deployment using the image tagged as blue. The Kubernetes deployment will internally create a replicaset and related pod. In the pod deployment template we set the label as app: blue.

The deployment is exposed outside the Kubernetes cluster using a Kubernetes service of the type loadbalancer. The service uses the selector with app: blue value.

Browse the public IP of the loadbalancer service and we will be presented with the web page with Blue background.

Step 2: Setup Green environment

The second step of the Blue-Green deployment is to create the Green environment. This is done by creating a 2nd Kuberentes deployment using the image nileshgule/blue-green-demo:green tag. We also set the label for the deployment as app: green. The rest of the attributes in the manifest file are almost same as the blue deployment. After applying the Green deployment, the service is still serving 100% traffic to Blue environment. We can perform test on the next version or release of the application which is deployed to the green environment. If the tests are successful, we can switch the traffic to green environment.

Step 3: Route traffic to Green environment

The final step in the Blue-Green deployment is to switch the traffic to the Green environment. We can do this by editing the service manifest. We update the selector to select the pods with app: green label. Apply this change to the Kubernetes service. All the traffic is now redirected to the Green environment.

Note that the Blue environment is still there, but the active or live traffic is served by the green environment. If there is any problem with the Green environment, we can change the selector in the service again to point back to the Blue environment quickly allowing us to revert the changes with minimal impact on the end users.

Youtube video

The steps explained in this blog post are demonstrated in the Youtube video in detail. Watch the video for a live demo and feel free to provide feedback in the video comments.

Conclusion

It is very easy to use the Blue-Green deployment strategy with Kubernetes using Service. This strategy is quite useful to reduce the downtime for stateless applications. Stateful applications are a bit more involved. This reduces the risk during application upgrades. By having a standby environment we can easily fallback to an older version with no downtime. Hope you found this useful.

Until next time, Code with Passion and Strive for Excellence.

Improve your productivity with Kubernetes using aliases

noreply@blogger.com (Nilesh Gule) — Thu, 13 Jan 2022 11:26:00 +0000

Background

Kubernetes is the de-facto standard for orchestrating containers. If you are working on a daily basis with Kubernetes, you are most likely using the kubectl to interact with the Kubernetes cluster for performing different operations like listing pods, checking for deployments, viewing logs etc. Working with kubectl using a terminal is the most common approach in such a scenario.

Earlier I had demonstrated how to use two power tools kubectx and kubens. In this post, we will look at how to give kubectl a huge productivity boost by using programmatically generated aliases.

A quick word on the alias

If you come from a scripting background with experience in bash or shell scripting or even Powershell scripts, you might be familiar with aliases. These are like shortcuts that we can add to the terminal session to execute a command or piece of code. One of the most commonly used alias while working with kubectl is k. Instead of typing kubectl every time, most people create an alias with k and we can replace/substitute kubectl with k.

We can persist the aliases across sessions and store them permanently. In the case of bash aliases on Linux or Unix systems, mostly these are stored in the .bashrc profile file under the home directory of the user. The same thing can be done on a Windows environment by creating a function as an alias in a PowerShell profile document.

Need for kubectl aliases

Now that we understand a bit about aliases, let us see how we can use them with Kubernetes and kubectl to be specific. Kubernetes has various objects like Pods, Deployments, Replicasets, Nodes, Endpoints, PersistentVolume, PersistentVolumeClaims etc. Each of these objects has support for different operations like create, update, delete, edit, get. Along with the different types of operations, there are also different flags that can be used while working with these objects using kubectl like -A or --all for listing objects from all namespaces.

Kubectl also supports displaying information in different formats like JSON or YAML. In order to improve efficiency and productivity while working with kubectl, we can alias the commonly used commands as shown below:

alias kg="k get"
alias kgpo="kg po" or alias kgpo="kg pods"
alias kgno="kg no" or alias kgno="kg nodes"
alias kd="k describe"
alias kaf="k apply -f"
alias kdf="k delete -f"

Note that some Kubernetes objects have short forms like po for pods and no for nodes. We can get the list of resources supported by Kubernetes along with their short names using the following command

kubectl api-resources

The above screenshot shows a partial list of resources, their short names, API versions etc.

If we were to create aliases for each of the resources and different operations supported for that resources, it will be a very time consuming and cumbersome process. This is where a smart guy names Ahmet Alp Balkan came up with a programmatic way to generate aliases for kubectl.

kubectl-aliases

The Github repository contains the list of over 800 aliases that are programmatically generated. It also contains instructions about how to set up these aliases. We need to download the file and source it in our bash profile which makes these aliases available for us to use with the terminal session.

There is a set of conventions followed while naming or generating these aliases.

k = kubectl

sys = --namespace kube-system

commands

g = get
d = describe
rm = delete
a : apply -f
ak : apply -k
k : kustomize
ex : exec -t -t
lo : logs -f

resources

po = pod
dep = deployment
ing = ingress
svc = service
cm = configmap
sec = secret
ns = namespace
no = node

flags

output formats : oyaml, ojson, owide
all : -all or --all-namespaces depending on command
sl : --show-labels
w : -w/--watch

value flags : should be at the end

n = -n/--namespace
f = -f/--filename
l = -l/--selector

Using these conventions it is quite convenient to work with kubectl. This reduces typing errors and improves our efficiency greatly. Here are a few examples

k get pods --> kgpo
k get pods --all-namespaces --> kgpoall
k get pods -n kube-system --> ksyspo
k get pods -o yaml -> kgpooyaml
k get configmaps -n keda --> kgcmn keda

If you are on Windows machine, you need not be left behind. There is a PowerShell version of these aliases. Here is the link to the Github repository created by Shanoor.

Youtube video

I created a short video demonstrating these in much more detail. Catch all the action in the below Youtube video.

Conclusion

We all want to improve our daily ways of working. I am sure you will benefit from this little tip if you are a regular user of Kubectl. Hopefully in your role as a developer or DevOps engineer or SRE role you find this useful. Do let me know in the comments of this post or in the Youtube video if you have any feedback.

Until next time, Code with Passion and Strive for Excellence.

How to prepare and clear CKAD certification exam

noreply@blogger.com (Nilesh Gule) — Wed, 05 Jan 2022 13:37:00 +0000

Background

The new year started on a happy note for me. A few days back, I cleared the Certified Kubernetes Application Developer (CKAD) certification. This was on the second attempt that I managed to clear the exam. It is the best online certification exam I have answered so far. This post is about my experience with the exam and how to prepare for it. I also share some information that might be helpful during the exam itself.

Exam Curriculum

The exam is completely hands on. There are no multiple choice questions. We are given a set of 6 different Kubernetes clusters. Each cluster has a different configuration and the questions are related to designing and developing cloud native applications in the Kubernetes environment. There are five different broad areas which are assessed as shown below. These include

Application Design and Build 20%
Application Deployment 20%
Application Observability and Maintenance 15%
Application Environment, Configuration and Security 25%
Services & Networking 20%

The exam is conducted by Linux Foundation in collaboration with Cloud Native Computing Foundation (CNCF). You can find out more about the exam on the Linux Foundation training website.

The duration of the test is 2 hours with 66% as the minimum passing score. The certificate is valid for 3 years. In case you are not able to clear on the first attempt, you get 1 free retake.

References for exam preparation

I like to use multiple resources while preparing for any certifications. For CKAD as well I referred to multiple sources of information. Here is a quick list of different references I used.

Kubernetes docs

We are allowed to refer to the Kubernetes docs during the exam. It is like an open book test. The following links are helpful for getting started with Kubernetes and understanding the different concepts.

Kubernetes docs - https://kubernetes.io/docs/home/
Kubernetes.io tasks - https://kubernetes.io/docs/tasks/
kubectl cheatsheet - https://kubernetes.io/docs/reference/kubectl/cheatsheet/

Learning course

Along with the Kubernetes docs, I supplemented the knowledge by registering for the eLearning course. There are many courses available online. Almost every eLearning platform will have one or more course related to the CKA exam preparation. Some also offer mock test. I took the CKAD exam plus the Kubernetes fundamentals bundle from Linux foundation.

The Kubernetes Certified Application Developer (CKAD) with Tests on Udemy by Mumshad Mannambeth is also one of the most popular courses.

I liked the details and the depth this course covers the contents. There are hands on labs or mini tests after every major topic. The course is filled with lots of gems in the form of tips and tricks related to the actual exam.

Github Repos

Here is a list of Github repositories I found useful

CKAD Excercises - https://github.com/dgkanatsios/CKAD-exercises
CKAD resources - https://github.com/lucassha/CKAD-resources
Nilesh Gule CKAD exam prep - https://github.com/NileshGule/ckad-exam-prep
Ahmet Alp Balkan Kubernetes network policy recipes - https://github.com/ahmetb/kubernetes-network-policy-recipes

Blogs

These blog posts provide useful tips for preparation as well as exam

Be fast with kubectl - https://faun.pub/be-fast-with-kubectl-1-18-ckad-cka-31be00acc443
How to nail Kubernetes certification exams - https://www.infoworld.com/article/3631108/how-to-nail-the-kubernetes-certification-exams.html
Codefresh Kubernetes cheatsheet - https://codefresh.io/kubernetes-tutorial/kubernetes-cheat-sheet/
CKAD practical challenge series - https://codeburst.io/kubernetes-ckad-weekly-challenges-overview-and-tips-7282b36a2681Tips

Watch out for discounts

You will find discounts during Black Friday, Cyber Monday, Christmas, New Year, Diwali, Eid etc. Make use of these discounts on learning courses as well as the actual test.

Learn Imperative commands

Due to the time limit of 2 hours, you need to be quick in finishing the tasks related to completing the exam. While you can copy and paste yaml from the Kubernetes documentation, editing it could take some time. The test will have specific requirements like naming Kubernetes objects with specific names and deploying them to a specific namespace. Usually, Kubernetes docs will deploy the objects in default namespace. It will save you quite some time if you know how to work with imperative commands. The output of these commands can be piped to yaml files and then you can make the required modifications instead of handcrafting the complete yaml from scratch.

Compared to CKA exam, I found the questions in CKAD to be lengthy. There are more subtasks for each question. You end up solving more subtasks and you need to be really fast.

Learn basic vi or nano editor commands

The test environment is Linux based. If you are coming from Windows background like me, you need to be familiar with vi or nano code editors. Be familiar with editing files and command like deleting lines of code, navigating to specific lines, updating a word, saving files etc.

Here is a handy cheatsheet I found to work with the vi editor more effectively.

Practice, Practice, practice

Whoever has cleared the CKA, CKAD or CKS exams will tell you that practice is the most important part of exam preparation. If you don't know how to work with the Kubernetes resources or objects using kubectl, there is no way you are going to clear this test. There could be multiple ways of achieving the same task. You need to find the one which is the most time efficient.

Bookmark specific links

Bookmarking the links from Kubernetes documentation is helpful to find the resource quickly. Instead of bookmarking the top level pages, I recommend bookmarking specific sections to avoid scrolling through the lengthy page looking for information.

Practice exam

If you book the Kubernetes related certification exam after June 2021, you will have access to the practice exam from Killer.sh. This exam gives you two attempts at the same test. The environment is available for 36 hours and answers along with a detailed explanation of the steps is provided to help you prepare better for real test.

Tips during the exam

Use external monitor (recommended), minimize screen switching
External keyboard and mouse can be used
Enable kubectl auto completions
create aliases (before starting test)
Update vimrc / editor profile
Time management

use imperative commands (huge time saver)
use copy feature instead of typing
use the notepad feature to make quick notes
flag questions for review
don't spend too much time on a single question (avg 5-6 mins)

verify solution after task completion

Aliases in bash profile

I added the following aliases in the bash profile to reduce typing kubectl commands

alias cls=clear
alias kg='k get'
alias kgpo='kg po'
alias kgno='kg no'
alias kdes='k describe'
alias kaf='k apply -f'
alias kdf='k delete -f'

Along with these aliases, I had also exported to handy commands

export do='--dry-run=client -o yaml'
export fg='--force --grace-period=0'

vi editor settings

Last but not the least, I also updated the settings for vi editor so that text can be aligned/indented properly when we tab in the editor. This also helps when we copy and paste the code snippets from Kubernetes docs.

set tabstop=2
set shiftwidth=2
set expandtab

Youtube video

All the topics mentioned in this post are explained in more detail in the Youtube video.

Conclusion

CKAD certification is meant to gauge the skills of Kubernetes developers. If you do not know how to build and deploy cloud-native applications which are deployed on the Kubernetes cluster, this certification is not for you. Practice well before taking the exam. There are 17 questions with different weights. Hope this post is helpful for those preparing for the exam in future.

Until next time, Code with Passion and Strive for Excellence.

How to install Metrics Server on Kubernetes cluster

noreply@blogger.com (Nilesh Gule) — Wed, 22 Dec 2021 15:29:00 +0000

Background

This post is about installing the Metrics Server on a Kubernetes cluster. We had provisioned a 3 node Kubernetes cluster in the previous post. In a multi-node cluster, the workloads will get scheduled on different nodes. If we want to find out which pods are consuming more resources or which nodes are having more resources, we need some way to aggregate the pod level metrics. This is where Metrics Server comes into the picture.

How to install Metrics Server on Kubernetes cluster

Kubernetes does not provide a default metrics aggregator. We need to install Metrics Server which helps to collect the container level metrics like CPU or RAM usage. These metrics can then be used by other Kubernetes APIs and objects like the Horizontal Pod Autoscaler (HPA) or Vertical Pod Autoscaler (VPA).

We will use a manifest file to install the required components onto our Kubernetes cluster. The manifest file is available in the Github repo for the Metrics Server project. Run the following command to apply the manifest

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

This will create the service account, RBAC for cluster role, cluster role binding, expose the metrics server as service etc. Verify these by listing the pods in the kube-system namespace

We can see that the metrics-server pod is running but the container is not ready. Use the describe command of Kubectl to identify the reason.

kubectl -n kube-system describe pod metrics-server-<<dynamic-name>>

In the events section, we can see there is a warning which suggests that the readiness probe failed. This happens because the pod is unable to establish communication with the Kube API server. We need to override some defaults to fix this issue.

Override the metrics server command

We will go and edit the metrics-server deployment. Use the following command to edit the deployment

k -n kube-system edit deploy metrics-server

scroll down into the section where we define the settings for the container. Add the following lines just before the image tag.

command:

- /metrics-server

- --kubelet-insecure-tls

- --kubelet-preferred-address-types=InternalIP

Save the changes. The deployment will kill the older version of the pod and recreate a new pod for the metrics server. After making the above changes we will be able to successfully run the metrics server on our Kubernetes cluster.

Verify Metrics Server functionality

Run the top command with node and pods subcommands to find out the resource usage at node & pods levels respectively. We can also examine the resource usage at the individual container level where there are multi-container pods by passing the --containers flag to the kubectl top pods --containers. Below screenshots show the output of these commands

Youtube video

All the steps mentioned here are demonstrated in the Youtube video.

Conclusion

Metrics Server helps to aggregate the CPU & RAM related metrics across nodes in a multi-node Kubernetes cluster. Hope you found this post useful. The default settings need to be overridden to allow insecure traffic between the kubelet and the metrics server.

Until next time, Code with Passion, Strive for Excellence

How to bootstrap multi node Kubernetes cluster on Azure using Kubeadm

noreply@blogger.com (Nilesh Gule) — Wed, 15 Dec 2021 05:21:00 +0000

Background

In the earlier post, I shared my experience with preparing and passing the Certified Kubernetes Administrator (CKA). Currently, I am preparing for the Certified Kubernetes Application Developer (CKAD). In order to prepare for this certification, I need a Kubernetes cluster where I can practice. I decided to create a 3 node Kubernetes cluster on Microsoft Azure using Kubeadm. This post is a step by step process of creating a Kubernetes cluster with version 1.22 on Azure.

Bootstrap k8s cluster on Azure using kubeadm

As of this writing, the CKAD certification is based on the 1.22 version of Kubernetes. The latest stable version of Kubernetes is 1.23. So I need a way to provision the cluster with the earlier version and not the latest version of Kubernetes. That is the reason I decided to provision Ubuntu Vms on Microsoft Azure and bootstrap the Kubernetes cluster with 1.22 version.

Here are the high level steps required to set up a brand new cluster on Azure:

Provision 3 Ubuntu VMs
Setup Docker, kubeadm, kubectl and Kubelet on each node
Install Control plane components on the master node
Setup pod network
Join worker nodes to the cluster

Provision Ubuntu VMs on Azure

There are multiple ways in which the VMs can be provisioned on Azure using the portal, Azure CLI, ARM template etc. I prefer to use Azure CLI commands to provision the VMs. Over the years I have used a bit of Powershell scripts to provision Azure resources. In this case, I have created a small Powershell script that provisions the 3 Ubuntu VMs on Azure with public IP. You can find the script in the Github repository. There is also an accompanying markdown file that walks through the different steps to set up the cluster. The script is parameterized and the following parameters can be overridden while executing the script

Subscription name
Resource group name
Resource group location

Setup Docker, kubeadm, kubectl and Kubelet on each node

Once the VMs are provisioned, we need to set up Docker, Kubeadm, Kubectl and Kubelet on each of the nodes. Using the RSA key provided during the VM provisioning, I ssh into each node and setup these prerequisites. Here is an example of how to login to the master node

ssh -i ~/.ssh/id_rsa azuser@kubeadm-ckad-master.southeastasia.cloudapp.azure.com

You can replace the hostnames for worker-1 and worker-2 to login to these VMs respectively.

Install Docker and enable the daemon so that Docker is restarted if the VM is rebooted.

sudo apt install docker.io -y

sudo systemctl enable docker

The current version of kubeadm, kubectl and kubelet are 1.23 but we need 1.22. We specify the version in the install command as follows

sudo apt install kubeadm=1.22.0-00 kubectl=1.22.0-00 kubelet=1.22.0-00 -y

With these prerequisites installed, we are ready to install the Kubernetes cluster.

Install Control plane components on the master node

Before we initialize the control plane components using Kubeadm init command, we need to make some modifications to the Docker and Kubelet settings. This is to set up systemd as the group driver. This setting has to match the container runtime and kubelet. Refer to the Kubernetes documentation for more details.

We override the Docker daemon configuration as shown below

cat <<EOF | sudo tee /etc/docker/daemon.json

{

"exec-opts": ["native.cgroupdriver=systemd"],

"log-driver": "json-file",

"log-opts": {

"max-size": "100m"

"storage-driver": "overlay2"

}

EOF

This needs to be done on all the nodes. On the master node, we also override the configuration for the Kubelet. You can find the kubeadm config yaml file in the repo. We use the file as overridden config along with the kubeadm init command as follows

sudo kubeadm init --config kubeadm-config.yaml

With these overrides, we should have the master node configured.

Setup pod network

Kubernetes does not come with built in pod network by default. We need to setup our own Container Networking Interface (CNI) based pod network so that pods can communicate with one another. CoreDNS will not start until this step is completed. We will use weavenet from Weaveworks.

kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"

Make sure that the master node is in a ready state after applying the above manifest file.

Join worker nodes to the cluster

The steps are exactly the same on the worker node for installing Docker, Kubeadm, Kubectl and Kubelet. The difference lies in the Kubelet configuration override. We do not need to do it on the worker node. However, we still need to override the Docker daemon configuration.

The last step is to join the worker node to the cluster. Whe the control plane is ready on the master node, the join command will be output along with the steps to copy the Kubeconfig file. Run the join command on each node and verify that all the 3 nodes are shown in ready state.

sudo kubeadm join 172.0.0.4:6443 --token pyyfr7.j97w0dcdpsajkgjl \

--discovery-token-ca-cert-hash sha256:e096df8d88421a8e1f1fae731e424deb21a8e055e80b0168f86f3661797fbe88

Note that the values will be different in your environment for the IP, token and the ca cert hash.

Youtube video

All the steps mentioned above are demonstrated in the Youtube video along with additional details like setting up the bash profile and testing the cluster with a test deployment. Watch the video to see it in action.

Conclusion

The Kubernetes 1.22 version requires some overrides to the Docker and Kubelet configuration to bootstrap using Kubeadm. The steps demonstrated here can be used on other cloud providers to set up a similar cluster once you have the Ubuntu based VMs ready. Hope this helps in your journey to learn more about Kubernetes.

Until next time, Code with Passion and Strive for Excellence.

How to prepare for CKA certification

noreply@blogger.com (Nilesh Gule) — Sun, 12 Dec 2021 01:34:00 +0000

Background

A few days back, I cleared the Certified Kubernetes Administrator (CKA) certification. This was on the second attempt that I managed to clear the exam. It is the best online certification exam I have answered so far. This post is about my experience with the exam and how to prepare for it. I also share some information that might be helpful during the exam itself.

Exam Curriculum

The exam is completely hands on. There are no multiple choice questions. We are given a set of 6 different Kubernetes clusters. Each cluster has a different configuration and the questions are related to administering the Kubernetes environment. There are five different broad areas which are assessed as shown below. These include

Storage 10%
Troubleshooting 30%
Workloads & Scheduling 15%
Cluster Architecture, Installation & Configuration 25%
Services & Networking 20%

The exam is conducted by Linux Foundation in collaboration with Cloud Native Computing Foundation (CNCF). You can find out more about the exam on the Linux Foundation training website.

The duration of the test is 2 hours with 66% as the minimum passing score. The certificate is valid for 3 years. In case you are not able to clear on the first attempt, you get 1 free retake.

References for exam preparation

I like to use multiple resources while preparing for any certifications. For CKA as well I referred to multiple sources of information. Here is a quick list of different references I used.

Kubernetes docs

Kubernetes docs - https://kubernetes.io/docs/home/
Kubernetes.io tasks - https://kubernetes.io/docs/tasks/
kubectl cheatsheet - https://kubernetes.io/docs/reference/kubectl/cheatsheet/

Learning course

Along with the Kubernetes docs, I supplemented the knowledge by registering for the eLearning course. There are many courses available online. Almost every eLearning platform will have one or more course related to the CKA exam preparation. Some also offer mock test. I took the CKA exam plus the Kubernetes fundamentals bundle from Linux foundation.

The Certified Kubernetes Administratr (CKA) with practice tests on Udemy by Mumshad Mannambeth is also one of the most popular courses.

Github Repos

Here is a list of Github repositories I found useful

Shubham Tatvamasi CKA - https://github.com/ShubhamTatvamasi/cka
Walid Shaari Kuberentes Certified Administrator - https://github.com/walidshaari/Kubernetes-Certified-Administrator
Nilesh Gule CKA prep - https://github.com/NileshGule/cka-prep
Denny Zhang kubectl cheatsheet - https://github.com/dennyzhang/cheatsheet-kubernetes-A4
Ahmet Alp Balkan Kubernetes network policy recipes - https://github.com/ahmetb/kubernetes-network-policy-recipes

Blogs

These blog posts provide useful tips for preparation as well as exam

Be fast with kubectl - https://faun.pub/be-fast-with-kubectl-1-18-ckad-cka-31be00acc443
How to nail Kubernetes certification exams - https://www.infoworld.com/article/3631108/how-to-nail-the-kubernetes-certification-exams.html
Codefresh Kubernetes cheatsheet - https://codefresh.io/kubernetes-tutorial/kubernetes-cheat-sheet/
CKA practical challenge series - https://levelup.gitconnected.com/kubernetes-cka-example-questions-practical-challenge-86318d85b4d
Rudi Martinsen CKA resources - https://rudimartinsen.com/cka-resources/

Tips

Watch out for discounts

You will find discounts during Black Friday, Cyber Monday, Christmas, New Year, Diwali, Eid etc. Make use of these discounts on learning courses as well as the actual test.

Learn Imperative commands

Learn basic vi or nano editor commands

Practice, Practice, practice

Whoever has cleared the CKA, CKAD or CKS exams will tell you that practice is the most important part of exam preparation. If you don't know how to administer the Kubernetes cluster there is no way you are going to clear this test. There could be multiple ways of achieving the same task. You need to find the one which is the most time efficient.

Bookmark specific links

Practice exam

Tips during the exam

Use external monitor (recommended)
Enable kubectl autocompletion
create aliases
Update vimrc / editor profile
Time management

use copy feature instead of typing
use the notepad feature to make quick notes
flag questions for review
don't spend too much time on a single question

verify solution after task completion

All the topics mentioned in this post are explained in more detail in the Youtube video.

Conclusion

CKA certification is meant to gauge the skills of a Kubernetes administrator. If you do not know how to administer the Kubernetes cluster, this certification is not for you. Practice well before taking the exam. There are 17 questions with different weights. Hope this post is helpful for those preparing for the exam in future.

Until next time, Code with Passion and Strive for Excellence.

How to manage Kubectl plugins using Krew package manager

noreply@blogger.com (Nilesh Gule) — Sun, 29 Aug 2021 01:56:00 +0000

Background

Currently, Kubernetes is the most popular container orchestration platform. Kubectl is the most popular command-line tool to interact with Kubernetes cluster. Kubernetes is quite extensible. In this post, we are going to see how to make use of kubectl plugin manager Krew to extend the functionality of Kubectl.

Krew plugin manager

You might have heard about package managers such as Homebrew for Mac, Chocolatey or Winget for Windows or apt-get for Linux. These package managers help us to search, install, uninstall and upgrade packages or software on our operating system. Similar to the package managers, there are plugins or extensions. These help to extend the functionality of a tool or program. The most common examples of plugins or extensions are found with browsers and also Integrated Development Environment(IDE) such as Visual Studio, IntelliJ Idea, Eclipse etc.

I hope you got the context now with regards to the plugins and package manager. Coming back to the topic of this blog post, we will look at Krew which is a package manager specifically for kubectl. As a plugin manager for kubectl, Krew performs 3 main activities

discover kubectl plugins
install them on your machine
keep the plugins up-to-date

As of this writing, there are 151 kubectl plugins that are distributed by krew. Krew is cross-platform and works on Windows, macOS and Linux. Note that there are some plugins that work only on a particular operating system.

In the video, we can see how to install Krew and work with different plugins.

Krew commands

Here are some of the commands demonstrated in the video related to krew

krew install krew - install krew on the system
kubectl krew list - list installed plugins
kubectl krew search - search available plugins
kubectl krew install [plugin name] - install a plugin
kubectl krew info [plugin name] - get info about the plugin
kubectl krew uninstall [plugin name] - uninstall a plugin
kubectl krew update - update the index of plugins
kubectl krew upgrade - upgrade plugin version

Useful Kubectl plugins

In the video, these plugins are demonstrated.

pod-lens

Pod-lens plugin shows the hierarchy of different objects related to a pod such as the namespace, container, services that interact with the pods, the associated persistent volume claim (PVC), secrets etc.

The output shows an interactive option to select the pods in a namespace. By default, it shows the summary for the selected pod and once we select an individual pod the plugin lists all the dependencies.

pod-dive

Pod dive gives a minimal view of pod. As compared to the pod-lens it shows a hierarchical view of pod along with the siblings which are pods running on the same node. This can be quite handy to know what other pods are running on the node where a specific pod is currently scheduled to run.

pod-inspect

Pod inspect is somewhat similar to pod-dive. Instead of showing the hierarchy, it depicts the information in a tabular format.

images

I particularly like the images plugin. It gives information about the container images in the Kubernetes cluster. This can be quite handy to know which all images are running in the cluster and what is the source of those images. There is also a quick summary presented at the top of the output which lists the number of namespaces, pods, containers and different versions of images.

rbac-view

The rbac-view plugin gives details about the ClusterRoles and Roles.

Conclusion

Krew is quite handy when it comes to extending the functionality of kubectl using plugins. It makes life easier for searching, installing and managing the plugins. Without Krew, it would be difficult to know what plugins are available and how to keep them updated. I demonstrated only a handful of plugins here. If you have used any other kubectl plugin and find it useful please recommend using the comments either on Youtube video or this blog post. I would love to hear feedback from viewers/readers about krew and different kubectl plugins.

Until next time, Code with Passion and Strive for Excellence.

Improve productivity while working with Kubernetes using kubectl power tools Kubectx and kubens

noreply@blogger.com (Nilesh Gule) — Tue, 24 Aug 2021 14:39:00 +0000

Background

If you are a DevOps or Site Reliability Engineer (SRE) engineer, most probably you will be working with multiple clusters. You might also be working with multiple namespaces across these clusters. It can be quite time consuming to switch between contexts and namespaces while working with the kubectl command-line tool.

kubectl power tools

Kubernetes is quite popular nowadays and it is very common for people to work with Kubernetes clusters using kubectl as command-line interface. Most people prefer to work with kubectl instead of working with GUI based tools.

For SRE and DevOps engineers as well as developers who are working with multiple clusters say for example Dev, staging / UAT and Production environments, they need to switch the context. In many enterprises, the Kubernetes clusters are shared by different teams. In order to isolate workloads, kubernetes namespaces are used. You need to provide the namespace everytime any command is executed.

In such scenarios switching between namespaces on the same cluster and also switch the whole context to point to a different cluster can be a cumbersome task. That is where I came across two power tools while working with kubectl, kubectx and kubens.

In the video, we can see how to install kubectx and kubens along with Fuzzy Search (FZF) tool for interactive mode.

Conclusion

Using kubectx and kubens helps to improve productivity while working with kubectl. We don't need to remember lengthy context names and also names of each and every namespace in the cluster. Get more productive by using these power tools.

Until next time, Code with Passion and Strive for Excellence.

DP-201 Designing an Azure Data Solution Exam Preparation Guide

noreply@blogger.com (Nilesh Gule) — Fri, 16 Oct 2020 14:45:00 +0000

Background

As part of Azure role based certifications, DP-201 Designing an Azure Data Solution certification exam is the 2nd in the list to get the Azure Data Engineer Associate certificate. I had cleared DP-200 exam earlier. Yesterday, I cleared DP-201 and achieved the Associate certification.

DP-201 Designing an Azure Data Solution Exam

This exam focusses on assessing the candidate in the following areas:

Design Azure Data Solutions (40-45%)
Design Data Processing Solutions (25-30%)
Design for Data Security and compliance (25-30%)

The primary skills are tested against the following core services from Azure

Azure Cosmos DB
Azure Synapse Analytics
Azure Data Lake Storage
Azure Data Factory
Azure Stream Analytics
Azure Databricks
Azure Blob Storage

Note: There are changes to the contents of the exam as of 31st July 2020. One notable exclusion from the list of services is the Azure SQL Database.

The test focusses on assessing the design skills of the candidate. It is not important to know so much about the code. We need to make the right design choices when selecting the services. Design options related to batch processing and stream processing are important. We also need to understand the different options related to disaster recovery and high availability.

All the questions are multiple-choice questions (MCQ). There are 2 case studies at the beginning of the test consisting of 9 questions. We can go back and forth on the questions within each case study and revise the answers. Once we mark the case studies as completed, we cannot go back and change the answers. The two case studies are followed by 30 questions. These questions are related to different services. Finally, there is one more case study with 3 questions towards the end. The trick here is that once a question answered, we cannot go back online the 2 earlier case studies.

Refer to the below Youtube video for more details about how I prepared for the test

Visual Notes taking

During the preparations, I also started experimenting with the visual notes taking approach. Instead of taking notes in the plain text, I started to make them more visual. Here are some examples of this approach.

I have published these visual notes to a GitHub repository in PDF as well as OneNote format. I hope people will find it useful in their preparations.

Conclusion

I found this test easier compared to DP-200. The focus of this test is on design skills and its important to understand the differences in different options available with the services. I hope you find this useful.

until next time, Code with Passion and Strive for Excellence.

Hacktoberfest DevOps with GitHub Actions

noreply@blogger.com (Nilesh Gule) — Sun, 11 Oct 2020 14:19:00 +0000

Background

In the month of October, DigitalOcean in partnership with Intel and Dev are celebrating the Hacktoberfest event across the globe. This is an annual event which aims to increase awareness of open source in communities all over the world. There are meetups and events scheduled all over in this regards. If you are an open-source contributor, you can get a free t-shirt by registering for the event and submitting at least 4 pull requests during the month of October. You can find out more about the event from the website

DevOps with GitHub Actions

The Hacktoberfest Singapore meetup was scheduled for Saturday 10 October with half-day event. I had the opportunity to present a topic on building DevOps pipelines with GitHub Actions. GitHub Actions allows us to automate workflows when certain events trigger on our repository.

In this session, we demonstrated 3 different scenarios

A simple workflow for linting codebase with Github Superlinter
A workflow involving third party integration with SonarCloud for static code analysis
CI CD workflow for deploying a containerized app with Azure Container Registry (ACR) and Azure Kubernetes Service (AKS)

The recording of the session is available on YouTube

Slides

The slides used during the session are available online
Slideshare - https://www.slideshare.net/nileshgule/devops-with-github-actions
Speakerdeck - https://speakerdeck.com/nileshgule/devops-with-github-actions

Source code

The source code of the demo used during the session is available on the GitHub repository

Conclusion

GitHub Actions provides an excellent option for automating workflows to run specific tasks when some event like code push or a release is triggered on the repository. The marketplace offers an opportunity for third-party vendors to provide actions for their products to integrate into automated workflows on repositories.

Until next time, Code with Passion and Strive for Excellence.

Scaling .Net containers with Azure Kubernetes Service and Serverless ACI

noreply@blogger.com (Nilesh Gule) — Fri, 18 Sep 2020 12:07:00 +0000

Background

Following my virtual session to the Microsoft Cloud South Florida user group last week, I was invited to deliver a similar virtual event. This time it was for Dear Azure user group in India. I am thankful to Kasam Shaikh the organizer of this event. The event was scheduled for Sunday afternoon. Given the relaxed time of 12:30 PM IST, we decided to have a 2 hours session. This was the first time I was present to the vibrant community in India.

Scaling .Net Containers with AKS and Serverless ACI

The theme of the session is similar to the last one. The main difference here was the duration. We scheduled it for 2 hours and that provided me with an opportunity to do a deep dive on some of the topics. We started off by looking at the components of the application consisting of a Web API as Producer for RabbitMQ. Then we looked at the consumer which is built as .Net Core executable. We went through the steps of building Docker images using Docker compose. We also looked at the benefits of Docker.

Next, we looked at private and public container registries. Kubernetes was our next logical step and we started by looking at the main features of Kubernetes.

RabbitMQ and KEDA were installed on Kubernetes cluster and the demo application was deployed using Kubernetes manifest files. In the closing stages of the demo, we looked at different options to scale a Kubernetes cluster. These included the manual scaling, Horizontal Pod Autoscaling (HPA) based on CPU or RAM utilization. There are cases when we need to scale not just on the resource usage but on some external factors. This is where we explored Kubernetes based Event Driven Autoscaling (KEDA). KEDA allows us to scale based on events.

Slight glitch

Usually, due to the time constraint, I prepare the demo environment beforehand and show the relevant bits during the live demo. This time since we had 2 hours at our disposal, I created the AKS clusters right at the start of the session. Most of the things which I wanted to show worked fine, except for a scenario of scaling onto the serverless Azure Container Instances (ACI). My backup cluster also had some problem. Lesson learnt that next time if I do a live cluster setup, the backup cluster needs to be tested thoroughly. I have done a similar demo at least 8-10 times in different forums. Maybe I became a bit overconfident that it would work.

YouTube video recording

The recording of this session is available on YouTube

Slides

The slides used during the session are available online
Slideshare - https://www.slideshare.net/nileshgule/scaling-containers-with-aks-and-aci

Speakerdeck - https://speakerdeck.com/nileshgule/scaling-containers-with-aks-and-aci

Conclusion

It was a wonderful experience to present to the vibrant developer community in India. The questions which were asked during the session prompted me to make changes to my demo which will be helpful for the future sessions.

Until next time, Code with Passion and Strive for Excellence.

Automate SonarCloud code scans using GitHub Actions

noreply@blogger.com (Nilesh Gule) — Mon, 07 Sep 2020 16:05:00 +0000

Background

In an earlier post / YouTube video, I had demonstrated how to automate code lining process using the GitHub Super Linter and GitHub action. In this post, we will explore how to use GitHub actions to automate the static code analysis using SonarCloud.

SonarCloud

You might have heard about SonarQube. It offers scanners for different programming languages. SonarCloud is cloud service which scans codebases for bugs, vulnerabilities and code smells. At the point of this writing, there are 24 mainstream programming languages supported which include:

C#
Java
Python
JavaScript
TypeScript
Go
Kotlin and others

SonarCloud provides detailed analysis across multiple dimensions of the code. These are helpful in identifying common mistakes done by developers and ensure that the code is of high quality. SonarCloud will also give an indicator of how much time is required to fix all the reported issues and remove the technical debt. The different dimensions are

Reliability
Security
Maintainability
Coverage
Duplications

SonarCloud also has Quality Gates and Quality Profiles. Quality profiles can be used to refine the rules which are applied to the code while scanning the files.

Automate code scan with GitHub action

In the video, we can see how to use GitHub Action to automate the code scan using SonarCloud GitHub Action.

Conclusion

SonarCloud offers a very good analysis of codebase by performing static code analysis. The ruleset can be customized as per the language and also based on organization policies. GitHub Actions make it very easy to automate the workflows. Combining the power of GitHub action and the SonarCloud we get an up to date insights about our code in an automated manner. I hope you found this post useful.

Until next time, Code with Passion and Strive for Excellence

Scaling .Net Core containers with Event Driven Workloads

noreply@blogger.com (Nilesh Gule) — Sat, 29 Aug 2020 04:55:00 +0000

Background

Due to the COVID-19 pandemic, many of the developer communities and user groups have been forced to conduct their regular session in a virtual manner. This has provided a great opportunity for organizers and speakers from across the globe to speak at community events and rope in speakers from different parts of the world. This might not have been possible in case of physical events.

I have been speaking at the local community events in Singapore as well as other parts of Asia for the past 3-4 years. Recently, I got opportunity to speak at the virtual meetup across the globe for the Microsoft Cloud South Florida user group.

It started off with a Tweet from Julie Larman that she is getting multiple requests for speaking opportunities but could not fulfil all. She suggested the organizers can extend the opportunities to others who might be interested and available to speak. I thought it was a good opportunity and replied to her tweet. The thread got picked up by Dave Noderer and we managed to set up a virtual meetup in no time.

Scaling .Net Core Containers with Event Driven Worksloads

I have presented the topic of autoscaling container using KEDA on multiple occasions in the past for different meetups and events in Asia. I also have a 3 part series on my recently launched YouTube channel about this. The duration of the meetup was 90 minutes and that provided me with an opportunity to do a deep dive on some of the topics which are not possible in a 45 minutes or 1 hour session.

The application I used in the demo is a dummy events management application called Tech Talks. There is a ASP.Net Core WebAPI which exposes a method to generate random events. These events are pumped into a RabbitMQ queue. We have a .Net Core exe which consumes these messages in a batch. It is the consumer which we use to showcase the autoscaling capabilities using an upcoming project called Kubernetes-based Event Driven Autoscaling (KEDA).

During the session, I demonstrated the following features

Containerize .Net Core Web API and executable using Dockerfile
Build and Publish docker images to a private container registry (Azure Container Registry)
Use Docker-compose to multiple services
Use YAML files to describe Kubernetes deployments
Provision AKS cluster using an idempotent Powershell script
Deploy RabbitMQ cluster using Helm charts
Deploy application containers to Kubernetes
Auto scale RabbitMQ consumer using KEDA
Extend the scaling capabilities to serverless Azure Container Instances (ACI) using Virtual Node

By the end of the session, we have expanded the containers to be auto scaled on to serverless Azure Container Instances (ACI) using Virtual Node.

YouTube video recording

The recording of this talk is now available on YouTube

Slides

The slides used during the session are available on

Source code

The source code is available in GitHub repository.

Conclusion

The session provided me an opportunity to speak for the first time across the globe. I like to attend in-person events as it helps a great deal to network with people. In a virtual event sometimes you feel like you are talking to a screen. It is difficult to gauge the reaction of the audience in virtual event.

One of the benefits of a virtual event is that we can focus more on the content delivery without getting distracted which could sometimes happen in a in-person event. Depending on which platform or communication tool is used (YouTube live stream / MS Teams/ Zoom etc) the question and answers can be handled separately. Aonther great advantage of virtual event is the ability to record it and share it on platforms like YouTube. People who could not attend due to timezone differences or due to emergencies can find these recording useful.

Until next time, Code with Passion and Strive for Excellence.

How to improve code quality using GitHub Super Linter

noreply@blogger.com (Nilesh Gule) — Sat, 22 Aug 2020 03:41:00 +0000

Background

As developers, we work on multiple programming languages like C#, Java, Python, JavaScript, SQL, etc. Apart from the mainstream programming languages, we also work with different file types like XML, JSON, YAML. Each of these languages and file types has their own styles and conventions. As a language or a format becomes mature, there are standards and best practices which get developed over a period of time.

Nowadays, many developers are full stack developers or polyglot developers. As part of the Microservices style of development, they might work on the web or Javascript based front end, a Java, C#, Go, Python or some other programming language based middle tier. And then some SQL or NoSQL backend. Each of these components can use a different language. And each language will have its own style. It can be very difficult for new or even experienced developers to follow all the best practices for all the languages at the same time.

Linter to the rescue

A linter is a software or an add on which will help to identify issues in a file with respect to the rules or conventions. It is a static code analysis tool which helps to automate the process of validating common errors, bugs, style-related errors. Some of the Integrated Development Environments have built-in linters for the common programming languages. Visual Studio, for example, can suggest changes to classes and methods. External tools and extensions like Resharper can also help. One of the most popular code editors, Visual Studio Code has many extensions which are specific to a particular language like

I tried doing a search for Linter in the Visual Studio Code Marketplace and as of this writing, there are more than 200 linters available.

All these linters help in making sure an individual developer can follow the rules and styles correctly on their development environment. Things get tricky when we work in teams and multiple developers are working on the same project. Each developer can have their personal opinion. To avoid having multiple styles for the same codebase, it is necessary to standardize the rules across the whole team.

These rules can then be automatically checked as part of the automated build process. All the modern day Continuous Integration (CI) systems like Azure DevOps, Jenkins, Bamboo, TeamCity, TavisCI etc. allow us to perform static code analysis.

GitHub Super Linter

Github recently announced what they call the Super Linter. GitHub also allows us to trigger certain actions based on some conditions like source code checkin into a master or main branch or a feature branch. These are called GitHub Actions.

The Super Linter is a collection of more than 30 linters for some of the most commonly used programming languages. With one GitHub action, we can scan the whole codebase and identify any issues in a single go. If the team has its own set of predefined rules for a particular language, we can customize the defaults to use the team or organizational rules.

In the video below, we can see how GitHub Super Linter can be configured for your repository and triggered using GitHub Action.

Conclusion

As demonstrated in the video, GitHub Super Linter can be a great tool for automating the static code analysis. It can easily help to standardize coding practices across multiple languages for teams and organizations. It is very easy to set up and can help a great deal in DevOps practices. Hope you find this useful.

Until next time, Code with Passion and Strive for Excellence.

DP-200 Implementing an Azure Data Solution Exam preparation guide

noreply@blogger.com (Nilesh Gule) — Mon, 10 Aug 2020 04:12:00 +0000

Background

Most of us are working from home due to the ongoing COVID-19 situation. This has saved some time in travelling for me personally. I managed to utilize some of this time to prepare for Azure Role-based certifications. In the past 3 months, I managed to clear AZ-301, AZ-400 and DP-200 certification exams. Many people have asked me about how did I go about preparing for these certifications. This post and the accompanying YouTube video is about my preparation for the DP-200 exam.

DP-200 Implementing an Azure Data Solution Exam

In case you are new to Microsoft Role-based certifications, have a look at this excellent post by Thomas Maurer about selecting the right exam. The DP 200 exam is focused on Data Engineer role and falls under the Data & AI category of tests. It is for the Associate level. I have been part of Data Engineering teams since late 2015. I have worked with Big Data technologies on Hortonworks Data Platform and also on Microsoft Azure. The exam consists of 3 main areas:

Implement data storage solutions (40-50%)
Manage and develop data processing (25-30%)
Monitor and optimize data solutions (30-35%)

Your skills are tested against following core services from Microsoft Azure:

Azure Data Lake Storage (ADLS) Gen 2
Azure Data Factory
Azure Databricks
Azure SQL
Cosmos DB
Azure Stream Analytics
Azure Key Vault
Azure Monitor

Since the test is focused towards implementing the Data solutions, we need to know the different options available for securing, managing, integrating and monitoring the solutions. I used the Linux Academy course for DP 200 to prepare for this exam. If you are new to Azure I recommend going through the MS Learn paths related to DP 200. Following learning paths are available on MS Learn

We need to understand batch processing, stream processing, structured & unstructured data, different APIs supported by Cosmos DB, different consistency levels. In terms of Data Integrations, it is important to understand the capabilities of Azure Data Factory. For Data Processing, Azure Databricks, Synapse Analytics and Stream Analytics play a very important role. If you are not familiar with the stream processing and real time data integration, focus on understanding the different Windowing mechanisms like sessions window, sliding window, tumbling window, hopping window etc.

The questions are all multiple choice questions (MCQ) based on case studies. For some questions, there is more than one correct answer and in such cases, we are also required to sequence the steps in the correct order. An example could be the data integration process which requires 5 steps. We are required to sequence all the steps correctly. The practice is very important due to this requirement.

Refer to the below YouTube video for more details about how I prepared for this exam

Conclusion

It is very important to practice as much as possible. The questions are not straightforward and involve selecting the right choices as well as making the right sequence of steps. I would also recommend using more than one reference material. Do not rely only on one source of information. I prefer to combine the eLearning courses from one of the platforms like Linux Acadamy, Pluralsight, Udemy etc. with MS Learn. I also do not recommend using dumps. In my opinion, dumps reduce the actual value of the certification. Please don't take shortcuts when learning new technology.

Until next time, Code with Passion and Strive for Excellence.