DEV Community: Rohith ND

🚀Zeroagent - World's first AI Work Assistant

Rohith ND — Mon, 25 Nov 2024 09:09:28 +0000

An agentic platform built to boost productivity and optimize workflows by eliminating manual tasks, reducing app-switching, and consolidating scattered data across multiple platforms.

👉 Get Started for Free - https://zeroagent.io/

🌟 What makes Zeroagent special?

1️⃣ Simplify Your Work: Just prompt to handle tasks, freeing up your time for what matters most.
2️⃣ AI-Driven Efficiency: Automate repetitive tasks across multiple business apps, all with simple commands.
3️⃣ Seamless Integration: Zeroagent connects to your existing tools, ensuring you never have to switch between apps again.
4️⃣ Boost Team Collaboration: Enhance team coordination by automating notifications, meeting schedules, and much more.

🔧 How it works:

Zeroagent connects with your apps and helps you with everything from scheduling meetings to managing projects and data. ✨ All it takes is a simple prompt like: "Schedule a sales team meeting and notify on Slack."

💼 Who is this for?

Individuals and enterprises to save time, automate repetitive tasks, improve collaboration, and boost productivity focusing on what truly matters.

We can’t wait to see how Zeroagent helps you achieve more with less effort! Try for free 👇
🌐 https://zeroagent.io/
📄 https://docs.zeroagent.io/
⏯️ https://www.youtube.com/@zeroagentio

Build Your First REST API in minutes using Zeromagic Flow Builder

Rohith ND — Tue, 01 Oct 2024 05:13:28 +0000

In this blog post, we'll explore how to create your first REST API on the Zeromagic Platform. Whether you're a beginner or an experienced developer, our intuitive Workflow Builder will guide you through setting up endpoints, defining data models, and handling HTTP requests. Let's dive in and see how you can quickly build and deploy a functional REST API with GET and POST methods, empowering your applications with seamless data interactions.

Step 1: Login to Project Console

Modules are often used to structure and organize API endpoints when building RESTful APIs. Each module can represent a specific domain or resource within your application.

Step 2: Create a new Module

Now click on Create Module button to create a new module. This open a form to create a new module. Enter the Name and API path of the module.

Note : API Path only follows the trailing slash.

Once module is created, click on the module and you will be directed to the Flow Builder Page where you can create your Rest API.

Step 3: Create a new Rest API

Look for a button labeled Create Rest API or + in the API List space within the interface. This button will initiate the process of creating a new REST API definition.
- Name : Name of the API
- Description:Short description of the API
- API Route: Define the base URL path that will be used to access the API endpoints. This path can include path parameters (indicated by {<param>}) to capture dynamic values in the URL.

Example: /users/{userId} (where {userId} would be a variable placeholder captured from the request URL).
- Authentication Method: If your API requires authentication to access certain or all resources, select the appropriate authentication method. Check on the Debug section to know more about authentication.
- Request Method: Specify the HTTP method that clients should use to interact with your API.

Step 4: Update Workflow to create Spell data in Database

The Worflow builder has 3 basic Blocks such API Endpoint, Build JSON and HTTP Response in the workflow canvas.

Now let's add Cosmos Create One block in the workflow to create Spell data in the database.

Assuming that the database is configured in the Database section of the Project Console.

In the "Cosmos Create One" options panel, locate the "container name" field (also referred to as "alias tables"). Enter "spell" as the container name (table name). Then, in the "Record to add" field, input the body data of your request

The container name field specifies the preferred name for your table (e.g., "spell"). This name will be used as an alias when accessing the table.

Toggle on Auto create to automatically create a new instance of the schema with the specified container if it is not already created.

Now in the HTTP Response update the Response Variable to {{$createOne.val}} which is output of the Cosmos Create One.

HTTP Response blocks accepts only JSON as response. Make sure your value in response is a JSON.

Now click on the Deploy button such that the API is automatically deployed and can be accessed in the specific environment.

Step 5: Test the POST method

1. Test using Platform

You can test your API by navigating to Logs section. Click on Debug button to provide your test data. Select the environment and provide the necessary body data.

Pass you APP-KEY in the headers (since your authentication is selected as APP-KEY) which can be found in your project settings.

Make sure to pass id key in the body data while using POST method.

Click on Test API and you can see the API logs in the page once your API is executed.

2. Test using Postman

You can access the API by selecting the specific environment you need. You can find the API Endpoint in the Details tab.

Copy the API endpoint and paste in the URL section of the postman. Select method to POST and nagivate to Headers and Body section to pass the required data.

You can also check the log of this particular request in the Logs section of the API in the Zeromagic console.

Step 6: Create new flow to GET Spell Data from DB

Now let's create a new Rest API to fetch Spell data. Click on the + icon on the RestAPI List section. Enter the details of the API required to fetch the Spell data.

Add the Cosmos Read Many block in the workflow to get all the information of the Spells from the database. Add the Container name, Sort Key and Sort Order in the Options panel.

Now in the HTTP Response update the Response Variable to {{$readMany.val}} which is output of the Cosmos Read Many.

Now click on the Deploy button such that the API is automatically deployed and can be accessed in the specific environment.

Step 7: Test the GET method

Navigate to the Logs section and click on the Debug button. Provide the necessary Headers according to the authentication settings.

With Zeromagic, creating powerful REST APIs is easier than ever. Sign up for Zeromagic and start building your first REST API in minutes. The future of API development is here.

Build SMS API in Minutes with ZeroMagic + Twilio Integration!

Rohith ND — Thu, 19 Sep 2024 15:41:11 +0000

Say goodbye to lengthy development cycles!
With ZeroMagic's intuitive flow builder and Twilio's powerful SMS API, you can create custom SMS workflows in minutes, not days.

No coding required!

Automate SMS notifications, reminders, and alerts
Integrate with your favorite apps and services
Scale your SMS workflows with ease

Get started now and transform your SMS automation game!

🚀 Introducing Zeromagic: The Future of AI-Powered API Development

Rohith ND — Wed, 11 Sep 2024 06:25:01 +0000

Zeromagic is now live, transforming the way APIs are built and managed for modern applications! 🎉

What is Zeromagic?

Zeromagic is an AI-powered, low-code platform that empowers developers to create RESTful and GraphQL APIs in a fraction of the time. With our advanced AI capabilities, you can generate APIs, data models, and more, allowing you to focus on building robust applications.

🌟 Key features:

AI-Powered API Generation: Build RESTful and GraphQL APIs 10x faster with our AI-driven tools.
GraphQL Query and Schema Builder: Automatically generate GraphQL queries and schemas based on your database structures.
REST API Flow Generator: Create REST API functionalities using simple prompts.
Unified API Management: Seamlessly connect your databases, REST/GraphQL endpoints, and third-party services.
Fully Managed Platform: Develop, deploy, and scale your microservices independently with ease.
Bring Your Own Business Database (BYOD): Integrate your existing databases or use our managed database solutions.

💡 Ready to experience the power of instant API creation?

Visit us at https://zeromagic.cloud/ and join our growing community of early adopters!

Docs: https://docs.zeromagic.cloud/
Blogs: https://docs.zeromagic.cloud/blog/

From Code to Cloud: Deploying Your Python App with Bunnyshell

Rohith ND — Mon, 11 Dec 2023 11:54:17 +0000

Welcome to the exciting journey of transitioning your python application from code to the cloud! We will take you step-by-step through the process of utilizing Bunnyshell to launch your python application in this blog.

As an Environments-as-a-Service platform, Bunnyshell enables full-stack environment creation and administration easier for development, staging, and production.

1. Creating a FastAPI app

In your designated directory, create a new folder named bunny-pyapp. This will serve as the home for your API project. Make a file called app.py inside the bunny-pyapp folder. The main functions of your API will be stored in this file. To prevent cross-origin resource sharing (CORS) issues when utilizing your API, incorporate the CORS Middleware in your app.py. This is an important step that guarantees your API and other applications communicate with one other seamlessly.

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware 
import uvicorn 

app = FastAPI() 

origins = ['*']

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
) 

@app.get("/")
async def root():
    return {"message": "Hello from FastAPI"} 

if __name__ == "__main__":
    uvicorn.run(app, host='0.0.0.0', port=8000)

After our script is finished, we'll check to see if the FastAPI is accessible.

$ python3 app.py

Point to http://localhost:8000/ after executing the following command to see the "Hello from Fastapi" message. A Swagger User Interface (UI) will appear when you route to http://localhost:8000/docs, assisting in the testing of your endpoints.

2. Creating a requirements.txt

To make it easier for us to install all of our packages, we now generate a requirements.txt file inside the "bunny-app" folder. You can use the command pip freeze > requirements.txt, or you can manually add them to the requirements.txt file.

fastapi
uvicorn
gunicorn

3. Signing to BunnyShell

Open the BunnyShell web page by pointing to this https://www.bunnyshell.com/ .Once the page is loaded click on to Log in and select 'Environments as a Service'.The page will reroute to the BunnyShell Dashboard upon successful login.

Our deployment process utilizes the power of Kubernetes pods, allowing for efficient scaling and resource management. Docker Compose is a well-known containerization tool, we use its familiar format to make the configuration of these pods easy for developers who are accustomed to it. It is also possible to configure your Kubernetes environment for easy deployment using Helm Charts, which are easily accessible.

4. Creating a Dockerfile

It's time to build the Dockerfile, which will serve as the blueprint for creating your bunny-app container image, within your project folder. To shape your container and get it ready for cloud deployment, add the following content:

# Specify base image
FROM python:3.9

# Set working directory
WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install -r requirements.txt

# Copy application code
COPY . .

# Expose application port
EXPOSE 5000

# Define command to run app
CMD ["python3", "app.py"]

This Dockerfile provides the foundation for building your bunny-app container image. The application code is copied, the base image is defined, required dependencies are installed, the application's port is exposed, and the command to run when the container starts is specified. Remember to update the Dockerfile with the details of your specific project requirements.

5. Creating a Docker compose

Now is the time to construct the docker-compose.yaml file within your project directory. This vital configuration file orchestrates the deployment and management of your bunny-app within docker containers. You may clearly outline the path your application will take to the cloud by specifying the services, ports, networks, volumes, and other variables.

version: '3.7'
services:
  bunnyapp:
    # Build the image from the local Dockerfile
    build: ./

    # Expose port 8000 for internal communication 
    ports:
      - 8000:8000

    # Define restart policy to automatically restart the service in case of failures
    restart: always

6. Push Code to Github repository

Create a repository of your choice. In this tutorial I'll be using bunny-app as repository name. To seamlessly push your code to GitHub, follow these steps in your bunny-pyapp folder.

git init
git remote add origin <git_url>
git add .
git commit -m "first commit"
git push -u origin master

Upon successfully pushing your bunny-app code to GitHub, head over to your repository to verify the contents.

7. Configuring Deployment

Locate the "Create environment" button, which is usually located in the interface's right corner. .A pop-up window will appear. Give your environment a name that explains such as bunny-app or a custom name reflecting your project. Press the "Create environment" button one more time. This will start Bunnyshell creating your customized environment.

Click on "Get Started" button and choose with "Docker Compose" or "Package JSON" to start your configuration.

Select your Git account (e.g., GitHub) and provide the repository name followed by branch and root application path. This allows Bunnyshell to access your code and build the environment.

Based on the organization of your project, Bunnyshell will automatically produce environment components. Inspect these elements carefully, taking note of the ports, volumes, and services. Adjust them as necessary to meet your unique needs.To move on to the last configuration stage, click "Continue".

Reviewing the entire environment configuration, including resource limitations, environment variables, and health checks, is possible here. Optimize the performance and resource utilization of your bunny-app by making any necessary adjustments. Click "Create Application" to finalize the configuration and build your application.

Note : Check over your context path for your build

Click the "Deploy" button located in the upper right corner once the project is finished. For deployment, choose the "Bunnyshell Cluster" that is offered by default. Change "Environment URL" to pythonapp or any other name that better represents your project. The public URL for your deployed application will be this one.

Click on the three dots menu beside your environment name and select Pipeline logs to view the detailed deployment process in real-time. This log will reveal any potential errors or warnings during the build and deployment stages.

Your application logs will appear simultaneously in the right panel of your Bunnyshell interface. These logs, which contain error messages, debug information, and application activity, provide insightful information about the behavior of your application during runtime.

Click the "Deployments" option from the dropdown menu beneath your "bunnyapp" name for more in-depth debugging and analysis. This will show the specifics of the Kubernetes deployment, including the logs of each individual container.

Access your environment by navigating to the URL https://bunnyapp-pythonapp.bunnyenv.com/. You should observe a displayed message on the page.

Hurray! Your Python app has successfully taken flight on Kubernetes pods with help of Bunnyshell environments.You may run applications created with different technology stacks thanks to Bunnyshell's power, which goes much beyond.

Deploying a Django App with Ingress for Multi-Path Routing on Kubernetes Pods

Rohith ND — Fri, 24 Feb 2023 18:42:56 +0000

In this blog post, I will guide you through the process of creating a Django app and deploying it in a Kubernetes cluster. Additionally, we will explore how to use an Ingress resource to route traffic to multiple paths on the Kubernetes pods.

Firstly, we will create a basic Django app and containerize it. Once we have our container image, we will create a deployment and service for our app. The deployment will manage the replicas of our app running in the cluster, and the service will expose our app to the cluster.

Next, we will create an Ingress resource to route traffic to our app. The Ingress resource will define the routing rules for incoming traffic based on the paths specified in the rules. We will create rules for two paths in our app, '/home' and '/page'.

Finally, we will deploy the Ingress controller in our cluster. The Ingress controller is a crucial component that will manage the Ingress resources in our cluster and route the incoming traffic to our app.

With these steps, we will have a fully functional Django app running in a Kubernetes cluster, and incoming traffic will be routed to our app based on the rules defined in the Ingress resource.

What is Kubernetes?

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. It provides features such as automatic scaling, rolling updates, self-healing, and service discovery, making it a popular choice for deploying containerized applications in production environments. It can be deployed on-premises, in the cloud, or in a hybrid environment, and integrates with a wide range of other tools and platforms.

What is Ingress?

Ingress is an API object that provides a way to manage external access to services in a cluster. It allows you to route traffic to different services based on rules defined in the Ingress resource. Ingress can be used to configure load balancing, SSL termination, and virtual host routing. In short, Ingress is a powerful tool for managing external access to applications running in a Kubernetes cluster.

An Ingress Controller is a component that is responsible for managing and configuring Ingress resources. It reads the rules defined in the Ingress resources and routes the incoming traffic to the appropriate services in the cluster. There are different types of Ingress controllers available, such as NGINX, Traefik, and Istio. Ingress controllers are an essential component in managing external access to services in a Kubernetes cluster.

Creating Django app

Open a terminal or command prompt and navigate to the directory where you want to create your project.

Run the following command to create a new Django project.



django-admin startproject <project_name>

Here I replace my <project_name> with djangokubernetesproject .Navigate to the project directory.Run the following command to create a new app.



python manage.py startapp <app_name>

Here I replace my <app_name> with app .Open the urls.py file in the project directory and add the following lines.



from django.contrib import admin
from django.urls import path , include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('app.urls')),
]

Now create an urls.py file inside your app directory. Define the URLs for your app.



from django.contrib import admin
from django.urls import path
from app.views import home , page
urlpatterns = [
    path('home/', home , name='home' ),
    path('page/', page , name='page' ),
]

Open your views.py file located in your app directory and add the following lines.



import os
from django.http import HttpResponse
# Create your views here.

def home(request):
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    print('ip address of the client = ' , ip)
    pod_name = os.environ.get('HOSTNAME') 


    return HttpResponse(
        '<h1>Hello World . ip address of the client = ' + str(ip) + '</h1>'
        '<h1>Hello World . pod name = ' + str(pod_name) + '</h1>' 
        )

def page(request):
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    print('ip address of the client = ' , ip)
    pod_name = os.environ.get('HOSTNAME') 


    return HttpResponse(
        '<h1>Hello World . ip address of the client = ' + str(ip) + '</h1>'
        '<h1>Hello World . pod name = ' + str(pod_name) + '</h1>' 
        )

Now open your settings.py file and add you app name in the INSTALLED_APPS.



INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app'
]

[Optional] : Open a terminal or command prompt and navigate to the project directory and run the following command to start the development server.



python manage.py runserver 0.0.0.0:8000

This will start the development server, and we can access our app by visiting http://localhost:8000 in a web browser.

Creating Docker file

Create a dockerfile in your django project directory. Here I am creating my dockerfile inside djangokubernetesproject directory.



# Base image
FROM python:3.9-slim-buster

# Set working directory
WORKDIR /app

# Copy and install requirements
COPY requirements.txt .
RUN pip install -r requirements.txt

# Copy project files
COPY . .

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Expose port
EXPOSE 8000

# Run the command to start the server
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Build a docker image

Once we have created the Dockerfile to configure our Django app, the next step is to build the Docker image and push it to a container registry. To do this, navigate to the project directory in the terminal and run the following commands



docker build -t <docker_hub_name>/django-ingress .

Here, replace <docker_hub_name> with your Docker Hub username. For example, if your username is ndrohith09, the command would be



docker build -t ndrohith09/django-ingress .

This command will build the Docker image with the specified name and tag. Make sure to include the period at the end of the command, as it indicates the build context.

Once the image is built, it's time to push it to the Docker Hub registry. To do this, run the following command:



docker push ndrohith09/django-ingress .

Now that your Docker image is pushed to the Docker Hub registry, you can use it to deploy your Django app on Kubernetes using Ingress.

Create kubernetes deployment file

To deploy our Django app on Kubernetes, we need to create a Kubernetes deployment file called django-ingress.yaml that defines the specifications for our application. In this case, we want to create a deployment that has two paths - /home and /pageNow we will create a kubernetes deployment file for the django app which has two paths '/home' and '/page'.

We will use the Docker image that we built and pushed to the Docker Hub container registry in the previous step. Here is an example deployment file that you can use:



 apiVersion: apps/v1
kind: Deployment
metadata:
  name: home
spec:
  replicas: 2
  selector:
    matchLabels:
      app: home
  template:
    metadata:
      labels:
        app: home
    spec:
      containers:
      - name: home
        image: ndrohith09/django-ingress
        ports:
        - containerPort: 8000

---

apiVersion: v1
kind: Service
metadata:
  name: home-svc 
spec:
  type: LoadBalancer
  ports:
  - port: 8000
    targetPort: 8000
    protocol: TCP
    name: http
  selector:
    app: home

--- 

apiVersion: apps/v1
kind: Deployment
metadata:
  name: page 
spec:
  replicas: 2
  selector:
    matchLabels:
      app: page
  template:
    metadata:
      labels:
        app: page
    spec:
      containers:
      - name: page
        image: ndrohith09/django-ingress
        ports:
        - containerPort: 8000

---

apiVersion: v1
kind: Service
metadata:
  name: page-svc 
spec:
  type: LoadBalancer
  ports:
  - port: 8000
    targetPort: 8000
    protocol: TCP
    name: http
  selector:
    app: page

Thus to configure the Django app with two paths /home and /page, we created two Kubernetes deployments, named home and page, and two services, named home-svc and page-svc.

After configuring the deployments and services, the next step is to update the django-ingress.yaml file to configure the ingress. We need to add specific rules and paths for routing the incoming traffic to the appropriate Kubernetes services.



apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: django-ing
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  tls:
  - secretName: tls-secret
  rules:
  - http:
      paths:
      - path: /home
        pathType: Prefix
        backend:
          service:
            name: home-svc
            port:
              number: 8000
  - http:
      paths:
      - path: /page
        pathType: Prefix
        backend:
          service:
            name: page-svc
            port:
              number: 8000

To create the Kubernetes services for the Django app, navigate to the project directory in the terminal and execute the relevant commands. These commands will create the services based on the deployment configurations and make them accessible to external traffic through the ingress controller.



kubectl create -f django-ingress.yaml

Note : It is important to understand that the ingress controller does not generate a public IP in local systems. As a result, we need to use cloud providers such as Oracle Cloud Infrastructure (OCI), Amazon Web Services (AWS), Google Cloud Platform (GCP), or Microsoft Azure, among others, that provide Kubernetes services to provision our services and generate a public IP. This will enable us to access our Django app from anywhere on the internet.

Deployment in Cloud platforms

Here, we will be deploying our Django app on a cloud platform, specifically on the Oracle Kubernetes Cluster (OKE). First, you need to create an Oracle Cloud account and navigate to the Kubernetes Clusters (OKE) page to create your own Kubernetes cluster. You can refer to the official documentation for creating a Kubernetes cluster in Oracle Cloud.

Docs: Creating a Kubernetes Cluster

After creating the Kubernetes cluster, you can access it using either the cloud shell access or local access.

Docs: Setting Up Cluster Access

Once you have access to your Kubernetes cluster, the next step is to set up the Ingress controller on the cluster. Ingress controllers are not a part of the Kubernetes core components, and there are different Ingress controllers available to choose from.

For Oracle Kubernetes Engine (OKE), the recommended Ingress controller is the Oracle Cloud Infrastructure (OCI) Load Balancing Ingress Controller. This controller is specifically designed for OKE and integrates with the Oracle Cloud Infrastructure Load Balancing service to provide a fully-managed, scalable and secure ingress solution for your cluster.

You can follow the official documentation to set up the OCI Load Balancing Ingress Controller on your OKE cluster.

Docs: Setting Up an Ingress Controller on a Cluster

Once the Ingress controller is installed and configured, you can proceed with creating and applying your Ingress resource YAML file (django-ingress.yaml) to configure routing to your Django app's services.

Note that the process for setting up an Ingress controller may differ depending on the cloud provider or infrastructure you are using. Make sure to refer to the relevant documentation for your platform to ensure proper setup and configuration of your Ingress controller.

To apply the services in the cluster, navigate to the project directory and use the following command to apply the django-ingress.yaml file



kubectl apply -f django-ingress.yaml

This will create the necessary resources in the cluster, including the ingress controller and the defined routes for our Django app. To get more details about the resources in your Kubernetes cluster, you can use the following command:



kubectl get all

This command will list all the resources in your cluster, including deployments, pods, services, and ingress. You can use this command to verify that your Django app is up and running, and that your ingress rules have been properly configured.

Once the resources are created, we can check the status of the ingress controller by running the following command



kubectl get ingress

This will display the details of the ingress resources created in the cluster, including the host, path, and backend service details. If the external IP address is not automatically generated by the cloud provider, we can check the status of the ingress resources by running the following command:



kubectl describe ingress

This will provide more detailed information about the ingress controller, including the IP address and any errors or warnings encountered during configuration.

With our ingress controller and services configured, we can now access our Django app using the external IP address provided by the ingress controller. You can retrieve the external IP address by running the command kubectl get ingress in your terminal. Once you have the external IP address, you can access your Django app by navigating to the defined paths in the browser, such as http://<external_ip_address>/home and http://<external_ip_address>/page.

To access the Django app, we can navigate to the defined paths '/home' and '/page' in the browser using the external IP provided by the ingress controller 144.24.133.172. This will route the requests to the respective Kubernetes pods and display the output on the browser.

To access the /home path of the Django app, you can use the following URL: http://144.24.133.172/home. This should display the HTML response that corresponds to the /home path that we defined earlier in our ingress configuration.

Similarly To access the /page path of the Django app, you can use the following URL: http://144.24.133.172/page. This should display the HTML response that corresponds to the /page path that we defined earlier in our ingress configuration.

Hope you have gained a good understanding of how to create a Django app and use Ingress to route traffic to multiple paths on Kubernetes pods.

ndrohith09 / django-ingress

Thank You!

Disclaimer: This article was created with the help of AI.

AI Based Art and Caption Generator and Color Restoration

Rohith ND — Wed, 14 Dec 2022 14:04:53 +0000

Hello everyone! This is one of my hackathon projects, and it can perform colour restoration, produce art from text, and generate captions for photographs.

With the rise of AI, it becomes easier for artists to express themselves without having to go through the process of creating an artwork. Artificial intelligence has the ability to consistently learn from past experiences and adapt to changes, making it the perfect candidate for eventually generating meaningful captions. Most vintage films are practically black and white, yet these films are not preferred by the current generation. We must convert them to coloured films so that old good films can be colourized for improved viewing. The conversion procedure can be expensive, but with the help of AI, the cost can be cut significantly.

Deploy FastAPI application on Digital Ocean with Nginx and Gunicorn

Rohith ND — Fri, 09 Dec 2022 05:10:49 +0000

In this blog, I will explain to you how to develop a FastAPI application and deploy it in Digital Ocean using Nginx and Gunicorn. Now let's start by creating a basic FastAPI application.

1. Creating FastAPI application

Create a folder called fast-api-ocean in your specified directory. Inside the directory create api.py file which contains the fastapi code. To avoid any CORS problems when using the API, we will additionally integrate CORS Middleware.



from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware 
import uvicorn 

app = FastAPI() 

origins = ['*']

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
) 

@app.get("/")
async def root():
    return {"message": "Hello from Fastapi"} 

if __name__ == "__main__":
    uvicorn.run(app, host='0.0.0.0', port=8000)

When our script is complete, we will test to see if the FastAPI is working.



$ python3 api.py

After running the following command point to the http://localhost:8000/ such that you find the message "Hello from Fastapi" displayed. On routing to http://localhost:8000/docs a swagger UI will be provided which helps to test your endpoints.

2. Creating requirements.txt

Now we create a requirements.txt such that we can install all of our packages at ease. You can either add them manually in requirements.txt file or else follow the command pip freeze > requirements.txt



fastapi
uvicorn
gunicorn

3. Creating Digital Ocean droplet

Sign in to your digital ocean account. Now on the top section click on Create and select Droplets .I have opted Banglore server region.

Now choose an image for the server. I am going with Ubuntu 22.10 x64 image.

You can select any of the CPU options. I chose 1GB RAM with 25GB NVMe SSD.

In Authentication Method I have selected SSH Key .

You can go with other options based on your droplet customization.

Now click on Create Droplet such that your droplet will be created. You can find your droplets in the Droplets section.

4. Accessing Droplet via SSH

You can access your droplet either by clicking on theConsole which is present on the top right corner. The other best and simple way is to access the droplet in you local machine using SSH. Copy the ipv4 address of your droplet.

You can access your droplet by executing the following command in your terminal. Here I am accessing as a root user.



$ ssh root@165.22.217.59

5. Copy files via SCP

Now we need to copy the folder which contains our code file such as api.py , requirements.txt from our local machine to the remote server. This can be achieved with the help of SCP. Open your terminal in your local-machine and navigate to your folder and execute the SCP command.



$ scp -r fast-api-ocean root@165.22.217.59:/root

Here I am copying my fast-api-ocean folder to the root of the remote server. Once copying is done you can navigate to /root/fast-api-ocean path and find you files.

6. Create a virtual environment

In the fast-api-ocean directory lets create a virtual environment using virtualenv



root@165.22.217.59:~/fast-api-ocean# pip install virtualenv
root@165.22.217.59:~/fast-api-ocean# virtualenv venv
root@165.22.217.59:~/fast-api-ocean# source venv/bin/activate

7. Nginx Configuration

To server the application over HTTP we have to make an Nginx config for our application. You can add any name to your app. Here I have specified as fast-api-ocean



(venv) root@165.22.217.59:~# sudo nano /etc/nginx/sites-available/fast-api-ocean

Add the following lines to the file. Place your IP domain in the server_name. My IP domain is 165.22.217.59 .



server{
       server_name 165.22.217.59; 
       location / {
           include proxy_params;
           proxy_pass http://127.0.0.1:8000;
       }
}

Now press ctrl+s to save the file and ctrl+x to exit. Then we create a symbolic link to this config file in the /etc/nginx/sites-enabled directory.



(venv) root@165.22.217.59:~# sudo ln -s /etc/nginx/sites-available/fast-api-ocean /etc/nginx/sites-enabled/

Then we restart the Nginx service.



(venv) root@165.22.217.59:~# sudo systemctl restart nginx.service

Now we can start our uvicorn server to check if our application is working or not.



(venv) root@165.22.217.59:~# gunicorn -w 4 -k uvicorn.workers.UvicornWorker api:app

We should be able to access the URL and view our application from a browser now that our application is serving and the proxy server is set up correctly.

8. Configure ASGI Server

Now that our application is deployed and configured properly one last thing to do is to create a service for the Gunicorn server so that it is constantly running and it automatically begins when the server is rebooted. Systemd will be used to build the service.



(venv) root@165.22.217.59:~# deactivate 
root@165.22.217.59:~# sudo nano /etc/systemd/system/fastapiocean.service

In this new file we will add the following lines



[Unit]
Description=Gunicorn instance to serve MyApp
After=network.target

[Service]
User=<username>
Group=www-data
WorkingDirectory=/root/fast-api-ocean
Environment="PATH=/root/fast-api-ocean/venv/bin"
ExecStart=/root/fast-api-ocean/venv/bin/gunicorn -w 4 -k uvicorn.workers.UvicornWorker api:app

[Install]
WantedBy=multi-user.target

Change the configurations to suit your system, save the file, and then close it.



root@165.22.217.59:~# sudo systemctl start fastapiocean.service

Our new service will be launched at this point, and our ASGI server will be running in the background.

Hurray! It's done. Now you can navigate to your IP-domain . Here in my case its http://165.22.217.59/ . Now you can find your FastAPI application running in the background in your droplets IP-domain .

I hope you find this blog helpful. Thank You.

Deploy a containerised Fast API application in Digital Ocean

Rohith ND — Tue, 06 Dec 2022 16:12:18 +0000

In this blog, I will explain to you how to develop a FastAPI application, containerize it, and deploy it in Digital Ocean. Now let's start by creating a basic FastAPI application.

1. Creating FastAPI application

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware 
import uvicorn 

app = FastAPI() 

origins = ['*']

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
) 

@app.get("/")
async def root():
    return {"message": "Hello from Fastapi"} 

if __name__ == "__main__":
    uvicorn.run(app, host='0.0.0.0', port=8000)

When our script is complete, we will test to see if the FastAPI is working.

python3 api.py

2. Creating requirements.txt

fastapi
uvicorn

3. Creating a docker file

Let's now create a dockerfile which is used to build Docker Images. It is a simple text file that consists of a set of instructions or commands that is executed by an automated build process in steps from top to bottom.

FROM python:3.10

WORKDIR /src

ADD ./ /src

RUN pip install --upgrade pip
RUN pip install --no-cache-dir -r requirements.txt

EXPOSE 8000 

CMD ["python", "api.py"]

Now our dockerfile is ready and we can create our image by using the following command.

docker build -t fast-ocean .

Once the image has been created, use the following command to execute it as a container. Now point to http://0.0.0.0:8000/ such that you can find your application running there.

docker run -p 8000:8000 fast-ocean

You can run the container in detached mode (in the background) by adding a tag -d

docker run -d -p 8000:8000 fast-ocean

4. Creating Digital Ocean droplet

Sign in to your digital ocean account. Now on the top section click on Create and select Droplets .I have opted Banglore server region.

Now choose an image for the server. I am going with Ubuntu 22.10 x64 image.

You can select any of the CPU options. I chose 1GB RAM with 25GB NVMe SSD.

In Authentication Method I have selected SSH Key .

You can go with other options based on your droplet customization.

Now click on Create Droplet such that your droplet will be created. You can find your droplets in the Droplets section.

5. Accessing Droplet via SSH

You can access your droplet by executing the following command in your terminal. Here I am accessing as a root user.

ssh root@165.22.217.59

Once you access your droplet type update all the packages.

apt-get update

6. Installing Docker in Digital Ocean Droplet

You can install docker in your droplet either by using snap or apt in your droplet terminal.

snap install docker
    # (or)
apt  install docker.io

Once your docker installation is done you can verify it by using the version command.

docker --version

7. Copy files via SCP

Now we need to copy the folder which contains our code file such as api.py , requirements.txt and dockerfile from our local machine to the remote server. This can be achieved with the help of SCP. Open your terminal in your local-machine and navigate to your folder and execute the SCP command.

scp -r fast-api-ocean root@165.22.217.59:/root

Here I am copying my fast-api-ocean folder to the root of the remote server. Once copying is done you can navigate to /root/fast-api-ocean path and find you files.

8. Building a docker image and running it in detached mode

As we installed docker in our Digital Ocean droplet now we can build the image with the help of the Dockerfile present in the fast-api-ocean folder.

docker build -t fast-ocean-droplet .

Now let's run the container in detached mode.

docker run -d -p 8000:8000 fast-ocean-droplet

Hurray! It's done. Now you can navigate to port 80 of your IP-domain . Here in my case its http://165.22.217.59/ . Now you can find your FastAPI container running in the background in your droplets IP-domain . The Dockerfile can be modified to suit your needs.

I hope you find this blog helpful. Thank You

Bluetooth Controlled Robot

Rohith ND — Sun, 07 Aug 2022 15:14:00 +0000

In this blog, I will show you how to build a bluetooth controlled robot with HC-05 bluetooth module and an Arduino microcontroller. You can use any bluetooth mobile app available in playstore to connect you mobile to bluetooth module.

Components required

Arduino UNO
HC-05
Gear Motors
IC L293D

Arduino UNO

Arduino is an opensource electronics platform based on easy-to-use hardware and software. Arduino boards are able to read inputs - light on a sensor , a finger on a button , or a twitter message - and turn it into an output - activating a motor , turning on a LED , publishing something online. To do so use the Arduino programming language (based on wiring) and the Arduino Software (IDE) based on processing.

HC-05 Bluetooth module

The HC-05 is a popular wireless module that can add two-way (full-duplex) functionality to your projects. You can use this module to communicate between two microcontrollers, such as Arduino, or to communicate with any Bluetooth-enabled device, such as a phone or laptop. Many Android applications are already available, making this process much easier.

Gear Motors

It is a DC motor with a gear box for decreasing the speed and increasing the torque and power . This type of motors is commonly used for robotic applications.

IC L293D

IC L293D is a dual H-bridge motor driver integrated circuit that can drive current of up to 600mA with voltage range of 4.5 to 36 volts.

In that Bluetooth app, tapping 0 turns the motor off, while pressing 1 causes the motor 1 to spin right. Similar to this, when tapping 2 , 3 and 4, the motors 1 turns left , the motor 2 turn right and the motor 2 spins left, respectively.

Code

int motorPin1 = 3;
int motorPin2 = 4;
int motorPin3 = 5;
int motorPin4 = 6;
int state;
int flag;
void setup() {
  Serial.begin(9600);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
}

void loop() {
  if (Serial.available() > 0) {
    state = Serial.read();
    flag = 0;
  }
  if (state == '0') {
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW );
    if (flag = 0) {
      Serial.println("MOTOR:off");
      flag = 1;
    }
  }
  else if (state == '1') {
    digitalWrite(3, LOW);
    digitalWrite(4, HIGH);
    if (flag == 0) {
      Serial.println("MOTOR1:right");
      flag = 1;
    }
  }
  else if (state == '2') {
    digitalWrite(3, HIGH);
    digitalWrite(4, LOW );
    if (flag == 0) {
      Serial.println("MOTOR1:left");
      flag = 1;
    }
  }
  else if (state == '3') {
    digitalWrite(5, LOW);
    digitalWrite(6, HIGH);
    if (flag == 0) {
      Serial.println("MOTOR2:right");
      flag = 1;
    }
  }
  else if (state == '4') {
    digitalWrite(5, HIGH);
    digitalWrite(6, LOW );
    if (flag == 0) {
      Serial.println("MOTOR2:LEFT");
      flag = 1;
    }
  }
}

Black Line Follower with Arduino

Rohith ND — Sat, 30 Jul 2022 09:07:33 +0000

In this blog, I will show you how to build a black line follower robot with an Arduino microcontroller and IR Sensors.

Components required

Arduino UNO
IR Sensor
Gear Motors
IC L293D

Arduino UNO

IR Sensor

An infrared sensor is an electronic device that emits and/or detects infrared radiation in order to sense some aspects of its surroundings.

Gear Motors

It is a DC motor with a gear box for decreasing the speed and increasing the torque and power . This type of motors is commonly used for robotic applications.

IC L293D

IC L293D is a dual H-bridge motor driver integrated circuit that can drive current of up to 600mA with voltage range of 4.5 to 36 volts.

Code

int leftir =2;
int rightir = 3;
int leftmotor =4;
int leftmotor1 = 5;
int rightmotor = 6;
int rightmotor1 = 7;

void setup() {
Serial.begin(9600);
pinMode(leftir,INPUT);
pinMode(rightir,INPUT);
pinMode(leftmotor,OUTPUT);
pinMode(leftmotor1,OUTPUT);
pinMode(rightmotor,OUTPUT);
pinMode(rightmotor1,OUTPUT);
}

void loop() {
 if(digitalRead(leftir) == HIGH && digitalRead(rightir) == HIGH);
 {
  digitalWrite(leftmotor ,HIGH);
  digitalWrite(leftmotor1,LOW);
  digitalWrite(rightmotor,HIGH);
  digitalWrite(rightmotor1,LOW);
  Serial.println("FORWARD");
  }
  if(digitalRead(leftir) == HIGH && digitalRead(rightir) == LOW);
 {
  digitalWrite(leftmotor ,HIGH);
  digitalWrite(leftmotor1,LOW);
  digitalWrite(rightmotor,LOW);
  digitalWrite(rightmotor1,HIGH);
  Serial.println("LEFT");

  }
   if(digitalRead(leftir) == LOW && digitalRead(rightir) == HIGH);
 {
  digitalWrite(leftmotor ,LOW);
  digitalWrite(leftmotor1,HIGH);
  digitalWrite(rightmotor,HIGH);
  digitalWrite(rightmotor1,LOW);
  Serial.println("RIGHT");
  }
   if(digitalRead(leftir) == LOW && digitalRead(rightir) == LOW);
 {
  digitalWrite(leftmotor ,LOW);
  digitalWrite(leftmotor1,HIGH);
  digitalWrite(rightmotor,LOW);
  digitalWrite(rightmotor1,HIGH);
  Serial.println("BACKWARD");
  }
}

Analog Input using Arduino

Rohith ND — Wed, 20 Jul 2022 09:37:29 +0000

In this blog, I will show you how to create an analog input using Arduino.

Components required

Arduino UNO
Potentiometer

Arduino UNO

Potentiometer

A three-terminal resistor with a sliding or revolving contact that creates a variable voltage divider is called a potentiometer. It functions as a variable resistor or rheostat if only the wiper and one end of the connector are used.

Code

int sensorPin = A0;    // select the input pin for the potentiometer
int ledPin = 13;      
int sensorValue = 0;  
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
  sensorValue = analogRead(sensorPin);
  digitalWrite(ledPin, HIGH);
  delay(sensorValue);
  digitalWrite(ledPin, LOW);
  delay(sensorValue);
}