DEV Community: Kumail Rizvi

Getting started with Radius: Run your first app

Kumail Rizvi — Sun, 21 Jan 2024 08:44:35 +0000

This guide will show you how to quickly get started with Radius. You’ll walk through both installing Radius and running your first Radius app.

Here we have a basic container which consist of our application and a Redis as Database .

1. Have your Kubernetes cluster handy

If you don’t have a preferred way to create Kubernetes clusters, you could try using k3d, which runs a minimal Kubernetes distribution in Docker.

Ensure your cluster is set as your current context:

kubectl config current-context

2. Install Radius CLI

For installation of radius cli , you can check the previous post for details about radius cli and installation.

Installation of Radius CLI

3. Initialize Radius

Create a new directory for your app and navigate into it:

mkdir first-app
cd first-app

Initialize Radius. For this example, accept all the default options (press ENTER to confirm):

rad init

Example output:

Initializing Radius...

✅ Install Radius v0.29
    - Kubernetes cluster: k3d-k3s-default
    - Kubernetes namespace: radius-system
✅ Create new environment default
    - Kubernetes namespace: default
    - Recipe pack: local-dev
✅ Scaffold application docs
✅ Update local configuration

Initialization complete! Have a RAD time 😎

In addition to starting Radius services in your Kubernetes cluster, this initialization command creates a default application (app.bicep) as your starting point. It contains a single container definition (demo).

// Import the set of Radius resources (Applications.*) into Bicep
import radius as radius

@description('The app ID of your Radius Application. Set automatically by the rad CLI.')
param application string

resource demo 'Applications.Core/containers@2023-10-01-preview' = {
  name: 'demo'
  properties: {
    application: application
    container: {
      image: 'ghcr.io/radius-project/samples/demo:latest'
      ports: {
        web: {
          containerPort: 3000
        }
      }
    }
  }
}

This file will run the ghcr.io/radius-project/samples/demo:latest image. This image is published by the Radius team to a public registry, you do not need to create it.

4. Run the app

Use the below command to run the app in your environment, then access the application by opening http://localhost:3000 in a browser.

rad run app.bicep

This command:

Runs the application in your Kubernetes cluster
Creates a port-forward from localhost to port 3000 inside the container so you can navigate to the app’s frontend UI
Streams container logs to your terminal

In your browser you should see the demo app:

Congrats! You’re running your first Radius app. When you’re ready to move on to the next step, use CTRL+ C to exit the command.

5. Add Database

This step will add a database (Redis Cache) to the application.

You can create a Redis Cache using Recipes provided by Radius. The Radius community provides Recipes for running commonly used application dependencies, including Redis.

In this step you will:

Add Redis to the application using a Recipe.
Connect to Redis from the demo container using environment variables that Radius automatically sets.

Open app.bicep in your editor and get ready to edit the file.

First add some new code to app.bicep by pasting in the content below at the end of the file.
This code creates a Redis Cache using a Radius Recipe:

@description('The environment ID of your Radius Application. Set automatically by the rad CLI.')
param environment string

resource db 'Applications.Datastores/redisCaches@2023-10-01-preview' = {
  name: 'db'
  properties: {
    application: application
    environment: environment
  }
}

Next, update your container definition to include connections inside properties. This code creates a connection between the container and the database. Based on this connection, Radius will inject environment variables into the container that inform the container how to connect. You will view these in the next step.

resource demo 'Applications.Core/containers@2023-10-01-preview' = {
  name: 'demo'
  properties: {
    application: application
    container: {
      image: 'ghcr.io/radius-project/samples/demo:latest'
      ports: {
        web: {
          containerPort: 3000
        }
      }
    }
    connections: {
      redis: {
        source: db.id
      }
    }
  }
}

NOTE:- Check the connection block in the above code block ,we will provide the redis connection with the demo application

our updated app.bicep will look like this:

// Import the set of Radius resources (Applications.*) into Bicep
import radius as radius

@description('The app ID of your Radius Application. Set automatically by the rad CLI.')
param application string

resource demo 'Applications.Core/containers@2023-10-01-preview' = {
  name: 'demo'
  properties: {
    application: application
    container: {
      image: 'ghcr.io/radius-project/samples/demo:latest'
      ports: {
        web: {
          containerPort: 3000
        }
      }
    }
    connections: {
      redis: {
        source: db.id
      }
    }
  }
}

param environment string
resource db 'Applications.Datastores/redisCaches@2023-10-01-preview' = {
  name: 'db'
  properties: {
    application: application
    environment: environment
  }
}

6. Rerun the application with a database

Use the command below to run the updated application again, then open the browser to http://localhost:3000.

rad run app.bicep

Navigate to the Todo List tab and test out the application. Using the Todo page will update the saved state in Redis:

Press CTRL+ C when you are finished with the website.

7. View the application connections

Radius Connections are more than just environment variables and configuration. You can also access the “application graph” and understand the connections within your application with the following command:

rad app connections

You should see the following output, detailing the connections between the demo container and the db Redis Cache, along with information about the underlying Kubernetes resources running the app:

Displaying application: demo

Name: demo (Applications.Core/containers)
Connections:
  demo -> db (Applications.Datastores/redisCaches)
Resources:
  demo (kubernetes: apps/Deployment)
  demo (kubernetes: core/Secret)
  demo (kubernetes: core/Service)
  demo (kubernetes: core/ServiceAccount)
  demo (kubernetes: rbac.authorization.k8s.io/Role)
  demo (kubernetes: rbac.authorization.k8s.io/RoleBinding)

Name: db (Applications.Datastores/redisCaches)
Connections:
  demo (Applications.Core/containers) -> db
Resources:
  redis-r5tcrra3d7uh6 (kubernetes: apps/Deployment)
  redis-r5tcrra3d7uh6 (kubernetes: core/Service)

So, we have Completed Building our First Application on Radius Successfully

if you have any comments or questions feel free to drop down below .

Thank You

Radius, a new open-source application platform for cloud-native apps by Microsoft

Kumail Rizvi — Sun, 17 Dec 2023 09:48:54 +0000

""Teaching meant for the hands enters most easily through the eyes.""
Morgan Llywelyn

INTRODUCTION

For developers, the complexity of managing infrastructure and lack of visibility into the resources that make up their applications are major roadblocks for productivity. For operators, the lack of standardization and automation in the deployment process can lead to loss of control over the infrastructure, and degradation of confidence in the applications that are deployed. At the end of the day, development teams are left with a disjointed experience between platforms and cloud providers. Developers and operators alike find themselves struggling to make sense of how their application comes together across disparate sets of tools that provide little more than a list of their deployed artifacts.

The Microsoft Azure Incubations team is excited to announce a new open application platform called Radius that places the application at the center of every stage of development—redefining how applications are built, managed, and understood.Radius is open-source and multi-cloud from the start, allowing for applications that can be written once and, using the same toolset and workflows, deployed to any cloud or on-premises infrastructure. To get started or learn more about Radius, visit radapp.io .

Lets dive deep into understanding what's radius is and what it is capible of , Radius in short can be described as a single tool to describe, deploy, and manage your entire application

What Radius Focus on the most

Focus of Radius:

Addresses platform engineering challenges in supporting application deployments across on-premises infrastructure and major cloud providers like Microsoft Azure and Amazon Web Services.

Compatibility and Integration:

Built-in support for popular app development tools like Dapr.
Integration with infrastructure as code (IaC) languages such as Terraform and Bicep.
Designed to meet developers and operators at their current workflow, integrating seamlessly into existing development tasks and CI/CD pipelines.

Developer-Friendly Approach:

Aims to enhance developers' understanding of their applications by managing all components efficiently.
Takes care of platform configurations, including permissions and connection strings, to simplify developers' tasks.

Non-Disruptive Implementation:

Designed to fit into existing development tasks and CI/CD pipelines without causing disruption.
Works alongside developers and operators, streamlining their workflows rather than requiring them to overhaul their processes.

Compliance and Policy Management:

Enables operators to ensure that all applications are deployed in compliance with organizational policies.
Offers a centralized solution for managing applications and their resources, providing a comprehensive approach to compliance and policy adherence.

Radius First Release Features

In this first release, the focus is on the features that are most foundational to the Radius platform and its goals of improving the productivity of application development workflows. These include:

Simplified and consistent application development experience: Deploy to any cloud provider or on-premises using the same application definition, all with a consistent set of tooling and experience. These include capabilities to automate resource access and provisioning, as well as the ability to configure environments that meet the needs of each phase of development.
Recipes and environments: Standardize and scale deployments with clear separation of concerns between developers and operators. Radius Recipes are pre-definable templates that automate the provisioning of infrastructure resources and environment configurations that can be designed to adhere to cost, security, and compliance standards.
Application graph: Gain visibility into the resources and relationships that make up an application. Radius captures the relationships between resources in an application as a part of the development activities, which can in turn be queried and understood.

For More Details check the offical docs https://blog.radapp.io/posts/2023/10/18/introducing-radius-a-new-open-source-application-platform-for-cloud-native-apps/

Setting up Radius

STEP 1: Installation of Radius CLI

For installation of Radius CLI (LINUX/MAC/WINDOWS)

https://docs.radapp.io/installation/#step-1-install-the-rad-cli

Verify the rad CLI is installed correctly by running rad version.

Example output:

RELEASE     VERSION     BICEP       COMMIT
0.28.0      v0.28        0.11.13     2e60bfb46de73ec5cc70485d53e67f8eaa914ba7

STEP 2: Install the VS Code extension

To install the Radius Bicep extension, search for Radius Bicep in the Extensions tab in VSCode or in the Visual Studio marketplace

Select Install
To verify you’ve installed the extension, open any file with the .bicep file extension and start authoring Radius application to verify the auto-complete and other validation features.

STEP 3: Initializing Radius

Initializing Radius installs the Radius control-plane and creates a Radius Environment. The control-plane is a set of services that provide the core functionality of Radius, running in the radius-systemnamespace.

Create a Kubernetes cluster

Radius runs inside Kubernetes. Create one from the supported k8s clusters

If you don’t have a preferred way to create Kubernetes clusters, you could try using k3d, which runs a minimal Kubernetes distribution in Docker.

Ensure your cluster is set as your current context:

kubectl config current-context

Initialize a new Radius Environment with rad init:

rad init

Select Yes to setup the app.bicep in the current directory

Initializing Radius...

🕔 Install Radius v0.28
   - Kubernetes cluster: kind
   - Kubernetes namespace: radius-system
⏳ Create new environment default
   - Kubernetes namespace: default
   - Recipe pack: local-dev
⏳ Scaffold application
⏳ Update local configuration

Verify the initialization by running:

kubectl get deployments -n radius-system

You should see:

NAME                      READY   UP-TO-DATE   AVAILABLE   AGE
applications-rp           1/1     1            1           53s
bicep-de                  1/1     1            1           53s
controller                1/1     1            1           53s
ucp                       1/1     1            1           53s
contour-contour           1/1     1            1           46s

You can also use rad env list to view your environment:

rad env list

We are now done setting up radius on our local machine

In the next part we will check a tutorial of creating an app using radius and its features in deep

Thank you

References
Offical Radius Documentation

Deploy Kubernetes Cluster via Ansible and Kind

Kumail Rizvi — Wed, 15 Feb 2023 09:47:25 +0000

Kubernetes has become the go-to solution for container orchestration, allowing developers to easily manage and scale their containerized applications. However, setting up and managing a Kubernetes cluster can be a complex task. This is where Ansible comes in – it is a powerful automation tool that can simplify the deployment and management of Kubernetes clusters. In this blog, we will explore how to use Ansible to deploy a Kubernetes cluster using KIND (Kubernetes IN Docker).

What is KIND?

KIND is a tool that allows you to run Kubernetes clusters inside Docker containers. It is lightweight and easy to set up, making it an ideal choice for testing and development environments. KIND also supports creating multi-node clusters, making it a good choice for more complex environments.

Setting up the environment

Before we can deploy a Kubernetes cluster using Ansible and KIND, we need to set up the environment. First, we need to install Docker and Ansible on our system. Then, we need to install KIND. We can do this by running the following command:

$ curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.11.1/kind-linux-amd64
$ chmod +x ./kind
$ sudo mv ./kind /usr/local/bin/kind

Once we have KIND installed, we can use it to create a new Kubernetes cluster. We can create a cluster with a single node by running the following command:

$ kind create cluster --name my-cluster

This will create a new Kubernetes cluster named "my-cluster" with a single node (you can use any name while creating a new cluster )

Deploying Kubernetes using Ansible

Now that we have our environment set up, we can use Ansible to deploy Kubernetes. Ansible allows us to automate the process of installing and configuring Kubernetes on our cluster.

First, we need to create an Ansible inventory file that specifies the hosts we want to configure. We can create a file named inventory.ini with the following contents:

[kubernetes-nodes]
localhost ansible_connection=local

This specifies that we want to configure the localhost host as a Kubernetes node.

Next, we need to create an Ansible playbook that defines the tasks we want to perform. We can create a file named deploy.yml with the following contents:

- name: Install Kubernetes
  hosts: kubernetes-nodes
  tasks:
  - name: Install kubeadm, kubelet, and kubectl
    become: true
    apt:
      name: ['kubelet','kubeadm','kubectl']
      state: present

  - name: Initialize Kubernetes cluster
    become: true
    command: kubeadm init --pod-network-cidr=10.244.0.0/16

  - name: Copy kubeconfig to user's home directory
    become: true
    copy:
      src: /etc/kubernetes/admin.conf
      dest: /home/user/.kube/config
      remote_src: yes

  - name: Install Calico CNI
    become: true
    command: kubectl apply -f https://docs.projectcalico.org/v3.14/manifests/calico.yaml

NOTE
Here iam using CNI ( Container Network Interface ) as Calico , you can use any different CNI such as Flannel, Canal etc

This playbook installs the necessary packages (kubelet, kubeadm, and kubectl), initializes the Kubernetes cluster using kubeadm, copies the kubeconfig file to the user's home directory, and installs the Calico CNI.

We can then run the playbook using the following command:

$ ansible-playbook -i inventory.ini deploy.yml

This will run the deploy.yml playbook on the localhost host, configuring it as a Kubernetes node and deploying the necessary components.

That's it and we are done. We created an Kubernetes cluster with the help of ansible and kind

Thank you and I hope you enjoy it.

References
https://docs.ansible.com/ansible/latest/playbook_guide/playbooks_intro.html
https://kind.sigs.k8s.io/
https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/
https://www.suse.com/c/rancher_blog/comparing-kubernetes-cni-providers-flannel-calico-canal-and-weave/#:~:text=In%20this%20article%2C%20we'll,containers%20are%20created%20or%20destroyed.