Recent posts

5 posts tagged with "python"

View All Tags

Understanding Windows IIS (Internet Information Services)

vivek

Windows Internet Information Services (IIS) is Microsoft’s robust, enterprise-grade web server designed to host web applications and services. It’s tightly integrated with the Windows Server platform and widely used for everything from static sites to dynamic web apps built with ASP.NET, PHP, or Python.

In this guide, we’ll walk through what IIS is, its key components, common use cases, how to configure it, and ways to troubleshoot typical issues.

What is IIS?#

Illustration of a thinking brain representing the concept of IIS and server logic

IIS is a feature-rich web server that supports multiple protocols including HTTP, HTTPS, FTP, FTPS, SMTP, and WebSocket. It’s often chosen in Windows-centric environments for its performance, flexibility, and ease of use.For an official overview, check out Microsoft’s IIS documentation.

It can host:

  • Static websites
  • Dynamic applications using ASP.NET, PHP, or Python
  • Web services and APIs

IIS provides powerful security controls, application isolation via application pools, and extensive monitoring features.

Core Components of IIS#

IIS Manager#

The graphical user interface for managing IIS settings, websites, and application pools.

Web Server#

Handles incoming HTTP(S) traffic and serves static or dynamic content.

Application Pools#

Isolate applications to improve stability and security. Each pool runs in its own worker process.

FastCGI#

Used to run non-native apps like PHP or Python. For Python apps, IIS commonly uses wfastcgi to bridge communication. Learn more about hosting Python apps on IIS.

SSL/TLS Support#

IIS makes it easy to configure HTTPS, manage SSL certificates, and enforce secure connections.

Key Features#

Person unlocking a padlock symbolizing IIS security and feature access

Security & Authentication#

Supports multiple authentication schemes like Basic, Integrated Windows Auth, and custom modules. Can be tied into Active Directory.

Logging & Diagnostics#

Robust logging and diagnostics tools to help troubleshoot performance and runtime issues.For troubleshooting guides, visit Microsoft’s IIS troubleshooting resources.

Performance & Scalability#

Features like output caching, dynamic compression, and bandwidth throttling help scale under load.

How to Configure IIS on Windows Server#

Install IIS#

  1. Open Server Manager → Add Roles and Features
  2. Choose Web Server (IIS) and complete the wizard
  3. Launch IIS Manager using inetmgr in the Run dialog

Add a Website#

  1. In IIS Manager, right-click Sites → Add Website
  2. Set Site name, physical path, and port
  3. Optionally bind a domain or IP

Configure Application Pool#

Each new website creates a pool, but you can customize it:

  • Set .NET version
  • Change identity settings
  • Enable recycling

Enable HTTPS#

  1. Right-click site → Edit Bindings
  2. Add HTTPS binding with an SSL certificate

Set File Permissions#

Ensure that IIS has read (and optionally write) permissions on your site directory.

Troubleshooting Common Issues#

Engineer pointing at a screen with gears representing IIS troubleshooting and diagnostics

Website Not Starting#

  • Check event logs for errors
  • Ensure app pool is running
  • Confirm no port conflicts

Permission Denied Errors#

  • Confirm folder/file permissions for IIS user

Python FastCGI Issues#

  • Validate wfastcgi.py installation
  • Confirm FastCGI settings in IIS Manager

Slow Performance#

  • Enable caching and compression
  • Use performance monitor tools

For more community-driven insights, explore the Microsoft IIS Tech Community.

Conclusion#

IIS remains a top-tier web server solution for Windows environments. Whether you're running enterprise ASP.NET applications or lightweight Python services, IIS delivers in performance, security, and manageability.

With the right setup and understanding of its components, you can confidently deploy and manage scalable, secure web infrastructure on Windows Server.

Looking to streamline your cloud infrastructure, application delivery, or DevOps workflows? Visit nife.io/solutions to discover powerful tools and services tailored for modern application lifecycles. and specialized support for Unreal Engine app deployment in cloud environments.

How to Delete Specific Lines from a File Using Line Numbers

Nida Sahar

When you're working with text files—be it config files, logs, or source code—you may need to delete specific lines based on their line numbers. This might sound intimidating, but it’s actually quite easy once you know which tool to use.

In this post, we’ll walk through several methods to remove lines using line numbers, using command-line tools like sed, awk, and even Python. Whether you're a beginner or a seasoned developer, there’s a solution here for you.

The Basic Idea#


To delete a specific range of lines from a file:

  1. Identify the start line and end line.
  2. Use a tool or script to remove the lines between those numbers.
  3. Save the changes back to the original file.

Let’s break this down by method.

1. Using sed (Stream Editor)#


sed is a command-line utility that’s perfect for modifying files line-by-line.

Basic Syntax#

sed 'START_LINE,END_LINEd' filename > temp_file && mv temp_file filename
  • Replace START_LINE and END_LINE with actual numbers.
  • d tells sed to delete those lines.

Example#

To delete lines 10 through 20:

sed '10,20d' myfile.txt > temp_file && mv temp_file myfile.txt

With Variables#

START_LINE=10
END_LINE=20
sed "${START_LINE},${END_LINE}d" myfile.txt > temp_file && mv temp_file myfile.txt

📚 More on sed line deletion

2. Using awk#

awk is a pattern scanning tool. It’s ideal for skipping specific lines.

Syntax#

awk 'NR < START_LINE || NR > END_LINE' filename > temp_file && mv temp_file filename

Example#

awk 'NR < 10 || NR > 20' myfile.txt > temp_file && mv temp_file myfile.txt

This prints all lines except lines 10 through 20.

📚 Learn more about awk

3. Using head and tail#

Perfect when you only need to chop lines off the start or end.

Example#

Delete lines 10 to 20:

head -n 9 myfile.txt > temp_file
tail -n +21 myfile.txt >> temp_file
mv temp_file myfile.txt
  • head -n 9 gets lines before line 10.
  • tail -n +21 grabs everything from line 21 onward.

📚 tail command explained

4. Using perl#

perl is great for more advanced file manipulation.

Syntax#

perl -ne 'print unless $. >= START_LINE && $. <= END_LINE' filename > temp_file && mv temp_file filename

Example#

perl -ne 'print unless $. >= 10 && $. <= 20' myfile.txt > temp_file && mv temp_file myfile.txt
  • $. is the line number variable in perl.

📚 Perl I/O Line Numbering

5. Using Python#

For full control or if you’re already using Python in your workflow:

Example#

start_line = 10
end_line = 20
with open("myfile.txt", "r") as file:
lines = file.readlines()
with open("myfile.txt", "w") as file:
for i, line in enumerate(lines):
if i < start_line - 1 or i > end_line - 1:
file.write(line)

Python is especially useful if you need to add logic or conditions around what gets deleted.

📚 Working with files in Python

Conclusion#


There are plenty of ways to delete lines from a file based on line numbers:

  • Use sed for simple, fast command-line editing.
  • Choose awk for conditional line selection.
  • Go with head/tail for edge-case trimming.
  • Try perl if you’re comfortable with regex and quick one-liners.
  • Opt for Python when you need logic-heavy, readable scripts.

Explore Nife.io for modern cloud infrastructure solutions, or check out OIKOS to see how edge orchestration is done right.

Running Python Scripts in a Virtual Environment: Why It Matters and How to Do It

Nida Sahar

Conceptual illustration of Python virtual environments

If you're a Python developer, you've probably heard about virtual environments. If not, no worries! In this post, we'll break down what they are, why they're super useful, and, most importantly, how to run your Python scripts inside one. Whether you're just starting out or looking to improve your workflow, this guide has got you covered.

What is a Virtual Environment?#

A virtual environment (often called a "venv") is like a personal workspace for your Python projects. It allows you to keep each project’s dependencies separate from your system’s global Python environment. This means that every project you work on can have its own set of libraries, avoiding conflicts between different versions. Sounds useful, right?

Let’s say you're working on two Python projects:

  • Project A needs Django 3.0.
  • Project B needs Django 4.0.

Without a virtual environment, this would be a problem because you can’t have both versions of Django installed globally at the same time. But with a virtual environment, each project gets its own isolated space with the exact dependencies it needs.

Why Use a Virtual Environment?#

Illustration depicting dependency isolation in Python virtual environments

Now that you know what a virtual environment is, you might be wondering why you should bother using one. Here’s why:

  • Avoid Dependency Conflicts – Each project can have its own versions of libraries without interfering with others.

  • Keep Your Codebase Clean – All dependencies stay inside the project folder, making it easy to share your code. You can also generate a requirements.txt file so others can install the exact dependencies you used.

  • Easier Dependency Management – You can add or remove libraries for a project without worrying about breaking other projects.

  • Simplifies Deployment – When you deploy your project to a server or share it with someone else, using a virtual environment ensures that everything works exactly as it does on your machine. No more "It works on my computer!" issues.

    Official Python venv Documentation

Setting Up a Virtual Environment and Running a Script#

Step-by-step guide to setting up and using a Python virtual environment

Let’s go step by step on how to create a virtual environment and run a Python script inside it.

1. Create a Virtual Environment#

Navigate to your project folder in the terminal or command prompt and run:

python3 -m venv myenv

This creates a new folder called myenv, which contains your virtual environment.

2. Activate the Virtual Environment#

Before using it, you need to activate the environment. The command depends on your operating system:

For macOS/Linux, run:

source myenv/bin/activate

For Windows, run:

myenv\Scripts\activate

Once activated, your terminal prompt will change to show that you’re working inside the virtual environment (you’ll likely see (myenv) at the beginning of the prompt).

3. Install Dependencies#

Now that your virtual environment is active, you can install any required python libraries . For example, if your script needs the requests library, install it like this:

pip install requests

Repeat this for any other libraries your script needs.

4. Run Your Python Script#

Now you’re ready to run your script. Simply use:

python path/to/your_script.py

Your script will now run with the libraries installed in your virtual environment.

5. Deactivate the Virtual Environment#

When you're done, deactivate the virtual environment by running:

deactivate

This will return you to your system’s global Python environment.

Final Thoughts#

Using a virtual environment is one of the best ways to keep your Python projects organized and prevent dependency issues. Each project gets its own isolated space, ensuring everything runs smoothly no matter what libraries you're using.

So, next time you start a new Python project, create a virtual environment—it’ll save you time and headaches down the road.

check out Nife.io (python App on Oikos)

How to Integrate Next.js with Django: A Step-by-Step Guide

Jigar Vishwakarma

Introduction#

By combining Next.js and Django, you can take use of both frameworks' strengths: Next.js provides a quick, server-rendered frontend, while Django offers a stable backend. In this tutorial, we'll create a basic book review application in which Next.js retrieves and presents book data that Django delivers over an API.

After completing this tutorial, you will have a functional setup in which Next.js renders dynamic book reviews by using Django's API.

Integrate Next.js with Django
---

Why Use Next.js with Django?#

✅ Fast Rendering: Next.js supports SSR (Server-Side Rendering) and SSG (Static Site Generation), improving performance.

✅ Separation of Concerns: Business logic is handled by Django, and UI rendering is done by Next.js.

✅ Scalability: Since each technology can grow on its own, future improvements will be simpler.

Step 1: Setting Up Django as the Backend#

1. Install Django and Django REST Framework#

Create a virtual environment and install dependencies:

# Create and activate a virtual environment
python -m venv venv
source venv/bin/activate # macOS/Linux
venv\Scripts\activate # Windows
# Install Django and DRF
pip install django djangorestframework

2. Create a Django Project and App#

django-admin startproject book_api
cd book_api
django-admin startapp reviews

3. Configure Django REST Framework#

In settings.py, add REST framework and the reviews app:

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

4. Define the Book Review Model#

In reviews/models.py:

from django.db import models
class BookReview(models.Model):
title = models.CharField(max_length=200)
author = models.CharField(max_length=100)
review = models.TextField()
rating = models.IntegerField()
def __str__(self):
return self.title

Run migrations:

python manage.py makemigrations
python manage.py migrate

5. Create a Serializer and API View#

In reviews/serializers.py:

from rest_framework import serializers
from .models import BookReview
class BookReviewSerializer(serializers.ModelSerializer):
class Meta:
model = BookReview
fields = '__all__'

In reviews/views.py:

from rest_framework.generics import ListAPIView
from .models import BookReview
from .serializers import BookReviewSerializer
class BookReviewListView(ListAPIView):
queryset = BookReview.objects.all()
serializer_class = BookReviewSerializer

Add a URL route in reviews/urls.py:

from django.urls import path
from .views import BookReviewListView
urlpatterns = [
path('reviews/', BookReviewListView.as_view(), name='book-reviews'),
]

Include this in book_api/urls.py:

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('reviews.urls')),
]

Run the server:

python manage.py runserver

You can now access book reviews at http://127.0.0.1:8000/api/reviews/.

Step 2: Setting Up Next.js as the Frontend#

1. Install Next.js#

In a new terminal, create a Next.js app:

npx create-next-app@latest book-review-frontend
cd book-review-frontend
npm install

2. Fetch Data from Django API#

Modify pages/index.js to fetch book reviews:

import { useState, useEffect } from "react";
export default function Home() {
const [reviews, setReviews] = useState([]);
useEffect(() => {
fetch("http://127.0.0.1:8000/api/reviews/")
.then(response => response.json())
.then(data => setReviews(data));
}, []);
return (
<div>
<h1>Book Reviews</h1>
<ul>
{reviews.map(review => (
<li key={review.id}>
<h2>{review.title} by {review.author}</h2>
<p>{review.review}</p>
<strong>Rating: {review.rating}/5</strong>
</li>
))}
</ul>
</div>
);
}

3. Start the Next.js Server#

Run:

npm run dev

Visit http://localhost:3000/ to see book reviews fetched from Django!

Step 3: Connecting Frontend and Backend#

Since Django and Next.js run on different ports (8000 and 3000), we need to handle CORS (Cross-Origin Resource Sharing).

1. Install Django CORS Headers#

In Django, install CORS middleware:

pip install django-cors-headers

Add it to settings.py:

INSTALLED_APPS += ['corsheaders']
MIDDLEWARE.insert(1, 'corsheaders.middleware.CorsMiddleware')
CORS_ALLOWED_ORIGINS = [
"http://localhost:3000",
]

Restart Django:

python manage.py runserver

Now, Next.js can fetch data without CORS issues!

Conclusion#

You've created a book review app by successfully integrating Next.js with Django. What we did was as follows:

  1. Use the Django REST Framework to install Django.
  2. To offer book reviews, an API was developed.
  3. Created a frontend using Next.js to show reviews.
  4. Set up CORS to allow front-end and back-end communication.

This setup provides a solid foundation for full-stack development. You can now extend it with Django Authentication, a database, or advanced UI components!

Looking to deploy your full-stack application seamlessly? Check out Nife.io a powerful platform for serverless deployment, scaling, and cloud cost optimization! 🚀

Further Reading#

How to Run Django as a Windows Service with Waitress and PyWin32

Nida Sahar

Setting up a Django project to run as a Windows service can help ensure that your application stays online and automatically restarts after system reboots. This guide walks you through setting up Django as a Windows service using Waitress (a production-ready WSGI server) and PyWin32 for managing the service. We'll also cover common problems, like making sure the service starts and stops correctly.

django

The Plan#

We'll be doing the following:

  1. Set up Django to run as a Windows service using PyWin32.
  2. Use Waitress to serve the Django application.
  3. Handle service start/stop gracefully.
  4. Troubleshoot common issues that can pop up.

Step 1: Install What You Need#

You'll need to install Django, Waitress, and PyWin32. Run these commands to install the necessary packages:

pip install django waitress pywin32

After installing PyWin32, run the following command to finish the installation:

python -m pywin32_postinstall

This step ensures the necessary Windows files for PyWin32 are in place.

Step 2: Write the Python Service Script#

To create the Windows service, we’ll write a Python script that sets up the service and runs the Django app through Waitress.

Create a file named django_service.py in your Django project directory (where manage.py is located), and paste the following code:

import os
import sys
import win32service
import win32serviceutil
import win32event
from waitress import serve
from django.core.wsgi import get_wsgi_application
import logging
# Set up logging for debugging
logging.basicConfig(
filename='C:\\path\\to\\logs\\django_service.log',
level=logging.DEBUG,
format='%(asctime)s - %(levelname)s - %(message)s'
)
class DjangoService(win32serviceutil.ServiceFramework):
_svc_name_ = "DjangoWebService"
_svc_display_name_ = "Django Web Service"
_svc_description_ = "A Windows service running a Django web server using Waitress."
def __init__(self, args):
win32serviceutil.ServiceFramework.__init__(self, args)
self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
self.running = True
logging.info("Initializing Django service...")
try:
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project_name.settings')
self.application = get_wsgi_application()
except Exception as e:
logging.error(f"Error initializing WSGI application: {e}")
def SvcStop(self):
self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
win32event.SetEvent(self.hWaitStop)
self.running = False
logging.info("Stopping Django service...")
def SvcDoRun(self):
logging.info("Service is running...")
serve(self.application, host='0.0.0.0', port=8000)
if __name__ == '__main__':
win32serviceutil.HandleCommandLine(DjangoService)
What’s Happening in the Script:#
  • Logging: We set up logging to help debug issues. All logs go to django_service.log.
  • WSGI Application: Django’s get_wsgi_application() is used to initialize the app.
  • Waitress: We serve Django using Waitress, which is a good production-ready server.
  • Service Methods:
    • SvcStop(): Handles stopping the service gracefully.
    • SvcDoRun(): Runs the Waitress server.

Step 3: Install the Service#

Once the script is ready, you need to install it as a Windows service. Run this command in the directory where your django_service.py is located:

python django_service.py install

This registers your Django application as a Windows service.

Note:#

Make sure to run this command as an administrator. Services need elevated privileges to install properly.

Step 4: Start the Service#

Now that the service is installed, you can start it by running:

python django_service.py start

Alternatively, you can go to the Windows Services panel (services.msc), find "Django Web Service," and start it from there.

Step 5: Troubleshooting Common Errors#

Error 1066: Service-Specific Error#

This error usually happens when something crashes during the service startup. To fix it:

  • Check Logs: Look at django_service.log for any errors.
  • Check Django Config: Make sure that DJANGO_SETTINGS_MODULE is set correctly.
Error 1053: Service Did Not Respond in Time#

This happens when the service takes too long to start. You can try:

  • Optimizing Django Startup: Check if your app takes too long to start (e.g., database connections).
  • Check Waitress Config: Ensure that the server is set up properly.
Logs Not Generated#

If logs aren’t showing up:

  • Ensure the directory C:\\path\\to\\logs exists.
  • Make sure the service has permission to write to that directory.
  • Double-check that logging is set up before the service starts.

Step 6: Stopping the Service Gracefully#

Stopping services cleanly is essential to avoid crashes or stuck processes. In the SvcStop method, we signal the server to stop by setting self.running = False.

If this still doesn’t stop the service cleanly, you can add os._exit(0) to force an exit, but this should be a last resort. Try to allow the application to shut down properly if possible.

Step 7: Configuring Allowed Hosts in Django#

Before you go live, ensure that the ALLOWED_HOSTS setting in settings.py is configured properly. It should include the domain or IP of your server:

ALLOWED_HOSTS = ['localhost', '127.0.0.1', 'your-domain.com']

This ensures Django only accepts requests from specified hosts, which is crucial for security.

Step 8: Package it with PyInstaller (Optional)#

If you want to package everything into a single executable, you can use PyInstaller. Here’s how:

First, install PyInstaller:

pip install pyinstaller

Then, create the executable:

pyinstaller --onefile django_service.py

This will create a standalone executable in the dist folder that you can deploy to other Windows machines.

Conclusion#

By following this guide, you’ve successfully set up Django to run as a Windows service using Waitress and PyWin32. You’ve also learned how to:

  1. Install and run the service.
  2. Debug common service-related errors.
  3. Ensure a clean shutdown for the service.
  4. Configure Django’s ALLOWED_HOSTS for production.

With this setup, your Django app will run efficiently as a background service, ensuring it stays available even after reboots.

For more information on the topics covered in this blog, check out these resources: