How to Build Your Own AI Agent Using Python and OpenAI (Step-by-Step 2026 Guide)

This tutorial is designed for developers who want to go beyond basic API calls and build a working conversational AI agent. If you're new to APIs, you may also find our guide on Understanding the OpenAI API for Developers helpful.

🚀 What is an AI Agent?

An AI agent is a system that can:

• Interact with users dynamically
• Maintain conversation context
• Make decisions based on input
• Provide intelligent responses

Unlike traditional chatbots, AI agents use memory and structured prompts to behave more like real assistants.

⚙️ Prerequisites Before You Start

Before running the code, ensure you have:

• Python 3.8 or higher installed
• Basic knowledge of Python
• Internet connection

Install required libraries:

• openai
• python-dotenv

🔑 How to Get Your OpenAI API Key

Follow these steps:

1. Go to OpenAI Platform
2. Create an account
3. Navigate to API Keys section
4. Generate a new secret key
5. Store it securely

Never hardcode your API key inside your code. Instead, use environment variables.

🔐 Using Environment Variables (.env)

Create a .env file in your project:

OPENAI_API_KEY=your_api_key_here

This keeps your credentials secure and prevents accidental exposure.

💻 Code Example: AI Career Agent

# Import the os module to interact with operating system features. This includes fetching environment variables.
import os
# Import the time module to perform time-related tasks, such as delays (sleep)
import time
# Import specific classes or functions directly from their modules to avoid prefixing them with the module name.
# Import the openAI library
import openai
from openai import OpenAI 
# Import the load_dotenv and find_dotenv functions from the dotenv package.
# These are used for loading environment variables from a .env file.
from dotenv import load_dotenv, find_dotenv

# Load environment variables from a .env file.
_ = load_dotenv(find_dotenv())

# Set the OpenAI API key by retrieving it from the environment variables.
openai.api_key  = os.environ['OPENAI_API_KEY'] 

# Print the version of the OpenAI library being used. 
print(openai.__version__)

# Initialize client
client = OpenAI()

# Store conversation history
conversation = [
    {
        "role": "system",
        "content": """
You are a professional AI career advisor.

Before giving advice, you must:
1. Ask about the user's education level.
2. Ask about technical background.
3. Ask about programming experience.
4. Ask about career goals.
5. Ask about time availability.

After collecting enough details,
create a customized AI career roadmap.
"""
    }
]

print("\n🤖 AI Career Assistant")
print("Type 'exit' to quit.\n")

while True:
    try:
        user_input = input("You: ")

        if user_input.lower() == "exit":
            print("Good luck with your AI journey 🚀")
            break

        # Add user message
        conversation.append({
            "role": "user",
            "content": user_input
        })

        # Send conversation to OpenAI
        response = client.responses.create(
            model="gpt-4.1-mini",  # Fast & affordable
            input=conversation
        )

        # Extract assistant reply safely
        reply = response.output_text

        print("\nAssistant:", reply, "\n")

        # Add assistant reply to memory
        conversation.append({
            "role": "assistant",
            "content": reply
        })

    except Exception as e:
        print("Error:", e)

  

🧠 Code Explanation (Step-by-Step)

Let’s break down how this AI agent works:

• Imports: Libraries like os and dotenv help manage environment variables securely.
• OpenAI Setup: The API key is loaded from the .env file and used to authenticate requests.
• Client Initialization: OpenAI() creates a client to interact with the API.
• System Prompt: Defines the behavior of the AI (career advisor).
• Conversation Memory: Stored in a list, allowing context-aware responses.
• While Loop: Keeps the conversation running until the user exits.
• User Role: Captures input from the user.
• Assistant Role: Stores AI responses for continuity.

🔄 Understanding Roles: System, User, Assistant

• System: Sets behavior and rules for the AI.
• User: Represents user input.
• Assistant: Represents AI responses.

These roles help maintain structured conversations and consistent outputs.

⚡ Advantages of Building Your Own AI Agent

• Full control over behavior and responses
• Customizable for any domain (career, finance, health)
• Scalable for production systems
• Better user experience with memory

🔒 Security & Risk Considerations

• Never expose API keys publicly
• Validate user input to prevent misuse
• Monitor API usage to control costs
• Be cautious with sensitive data

Always follow best practices when deploying AI systems in production.

⚡ Key Takeaways

1. AI agents are more advanced than traditional chatbots.
2. Environment variables protect your API keys.
3. Conversation memory enables intelligent responses.
4. System prompts define AI behavior.
5. Security is critical in AI applications.
   
   

💬 Found this article helpful? Please leave a comment below or share it with your network to help others learn!

About LK-TECH Academy — Practical tutorials & explainers on software engineering, AI, and infrastructure.

Building an Intelligent Web Scraper with Python and OpenAI (2026 Complete Guide)

If you already understand the basics of Web Scraping with Python, this tutorial will take your skills to the next level. We'll explore architecture design, practical implementation, advanced AI prompts, structured data extraction, and production-ready best practices.

🚀 Why Intelligent Web Scraping Matters in 2026

Traditional web scrapers rely heavily on CSS selectors and XPath rules. The problem? Websites change layouts frequently. A small HTML modification can break your entire scraper.

Intelligent web scrapers solve this using AI to:

• Understand page context instead of relying only on tags
• Extract structured data from messy content
• Summarize scraped information automatically
• Adapt to minor structural changes
• Perform semantic classification on scraped data

By integrating OpenAI models via API, we can parse unstructured HTML into clean JSON outputs without manually defining dozens of selectors.

🧠 Architecture of an AI-Powered Web Scraper

Let’s break down the core architecture when building an intelligent web scraper with Python and OpenAI:

1. Data Collection Layer – Requests, BeautifulSoup, or Playwright
2. Preprocessing Layer – HTML cleaning and noise reduction
3. AI Parsing Layer – OpenAI API for semantic extraction
4. Post-processing Layer – JSON validation and normalization
5. Storage Layer – Database or data pipeline

Instead of writing fragile parsing logic, we delegate understanding to a large language model.

💻 Code Example: AI-Powered Product Scraper

import requests
from bs4 import BeautifulSoup
from openai import OpenAI
import json

# Initialize OpenAI client
client = OpenAI(api_key="YOUR_API_KEY")

url = "https://example.com/product-page"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")

# Extract visible text only
page_text = soup.get_text(separator="\n")

prompt = f"""
Extract the following details from the text:
- Product Name
- Price
- Description
- Key Features

Return output in JSON format.

TEXT:
{page_text}
"""

completion = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": prompt}],
)

result = completion.choices[0].message.content

print(result)

  

Instead of manually parsing tags, the AI understands context and returns structured JSON. This is where intelligent scraping becomes powerful.

⚙️ Advanced Prompt Engineering for Scraping

The quality of your extraction depends heavily on your prompts. Best practices include:

• Clearly defining output structure
• Providing examples of expected JSON
• Limiting token size by cleaning HTML first
• Using temperature=0 for consistent structured output

For production-level usage, consider chunking large pages and merging AI responses. You can learn more about optimizing AI workflows in our guide on Understanding the OpenAI API for Developers.

🔒 Handling Dynamic Websites and JavaScript

Many modern websites render content dynamically using JavaScript. In such cases:

• Use Playwright or Selenium to render pages
• Extract final DOM after JavaScript execution
• Feed cleaned content into OpenAI for parsing

Combining browser automation with AI parsing creates a powerful hybrid solution.

📊 Real-World Applications

• Competitor pricing intelligence
• Automated news summarization
• Market research data extraction
• Academic research automation
• E-commerce analytics dashboards

Always respect website terms of service and robots.txt policies. Review legal guidance from sources like EFF Web Scraping Legal Guide before large-scale deployments.

⚡ Key Takeaways

1. AI makes scrapers resilient to layout changes.
2. Prompt engineering determines extraction quality.
3. Preprocessing HTML improves token efficiency.
4. Dynamic rendering tools enhance scraping coverage.
5. Ethical scraping practices are essential.

💬 Found this article helpful? Please leave a comment below or share it with your network to help others learn!

About LK-TECH Academy — Practical tutorials & explainers on software engineering, AI, and infrastructure. Follow for concise, hands-on guides.

GitOps in Practice: Automating Kubernetes Deployments with ArgoCD and Kustomize

🚀 Why GitOps Matters in 2025

GitOps represents a paradigm shift in infrastructure management where Git becomes the single source of truth for both application code and infrastructure configuration. The core principle is simple yet powerful: if you want to deploy something, commit it to Git. This approach brings several critical advantages in today's complex cloud-native landscape:

• Enhanced Security: All changes are tracked, auditable, and require pull requests with proper reviews
• Improved Reliability: Automated synchronization ensures your cluster state always matches the declared configuration
• Faster Recovery: Rollbacks become as simple as reverting a Git commit
• Developer Empowerment: Developers can deploy safely using familiar Git workflows without deep Kubernetes expertise
• Multi-environment Consistency: The same deployment process works across development, staging, and production

🔧 Understanding the GitOps Toolchain: ArgoCD + Kustomize

ArgoCD serves as the GitOps operator that continuously monitors your Git repositories and automatically syncs your Kubernetes clusters with the desired state. Kustomize, now built into kubectl, provides template-free customization of Kubernetes manifests for different environments without duplicating configuration.

This powerful combination addresses the fundamental challenge of environment-specific configurations while maintaining Git as the single source of truth. Let's examine how they work together:

• ArgoCD: Monitors Git repos and automatically applies changes
• Kustomize: Manages environment-specific overlays
• Git: Serves as the declarative source of truth
• Kubernetes: The target platform where applications run

💻 Setting Up Your GitOps Repository Structure

Proper repository organization is crucial for maintainable GitOps workflows. Here's the recommended structure that scales from small projects to enterprise deployments:

gitops-repository/
├── apps/
│   ├── base/
│   │   ├── kustomization.yaml
│   │   ├── deployment.yaml
│   │   ├── service.yaml
│   │   └── configmap.yaml
│   ├── overlays/
│   │   ├── development/
│   │   │   ├── kustomization.yaml
│   │   │   └── patch-deployment.yaml
│   │   ├── staging/
│   │   │   ├── kustomization.yaml
│   │   │   └── patch-deployment.yaml
│   │   └── production/
│   │       ├── kustomization.yaml
│   │       └── patch-deployment.yaml
├── infrastructure/
│   ├── monitoring/
│   ├── networking/
│   └── storage/
└── cluster-config/
    ├── base/
    └── overlays/

  

🛠 Implementing Kustomize for Environment Management

Kustomize enables you to manage multiple environments without copying and modifying entire YAML files. Let's create a complete example showing base configuration and environment-specific overlays.

First, create your base application configuration:

# apps/base/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
- deployment.yaml
- service.yaml
- configmap.yaml

commonLabels:
  app: my-webapp
  managed-by: kustomize

namePrefix: dev-
namespace: my-webapp

images:
- name: nginx
  newTag: 1.25.3

  

Now create environment-specific overlays. Here's the development overlay:

# apps/overlays/development/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
- ../../base

namePrefix: dev-
namespace: my-webapp-dev

patchesStrategicMerge:
- patch-deployment.yaml

configMapGenerator:
- name: app-config
  behavior: merge
  literals:
  - ENVIRONMENT=development
  - LOG_LEVEL=debug
  - DATABASE_URL=postgresql://dev-db:5432/app

replicas:
- name: dev-my-webapp
  count: 2

  

🚀 Deploying ArgoCD in Your Kubernetes Cluster

ArgoCD installation has become more streamlined in 2025 with improved Helm charts and operator support. Here's the modern approach to deploy ArgoCD:

# Add the ArgoCD Helm repository
helm repo add argo https://argoproj.github.io/argo-helm
helm repo update

# Create namespace for ArgoCD
kubectl create namespace argocd

# Install ArgoCD using Helm
helm install argocd argo/argo-cd \
  --namespace argocd \
  --set server.service.type=LoadBalancer \
  --set server.ingress.enabled=true \
  --set server.ingress.hosts[0]=argocd.yourdomain.com \
  --set dex.enabled=false \
  --set redis.enabled=true

# Get initial admin password
kubectl -n argocd get secret argocd-initial-admin-secret \
  -o jsonpath="{.data.password}" | base64 -d

# Access the ArgoCD UI
kubectl port-forward svc/argocd-server -n argocd 8080:443

  

🔗 Configuring ArgoCD Application with Kustomize

Now let's connect ArgoCD to your Git repository and configure it to use Kustomize for deployment management. This is where the magic happens!

# applications/my-webapp-dev.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-webapp-dev
  namespace: argocd
spec:
  project: default
  
  source:
    repoURL: https://github.com/your-org/gitops-repo.git
    targetRevision: HEAD
    path: apps/overlays/development
    kustomize:
      namePrefix: dev-
      namespace: my-webapp-dev
  
  destination:
    server: https://kubernetes.default.svc
    namespace: my-webapp-dev
  
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
      allowEmpty: false
    syncOptions:
    - CreateNamespace=true
    - ApplyOutOfSyncOnly=true
    
    retry:
      limit: 5
      backoff:
        duration: 5s
        factor: 2
        maxDuration: 3m

  

Apply the ArgoCD Application configuration:

# Apply the ArgoCD Application
kubectl apply -f applications/my-webapp-dev.yaml

# Check application status
argocd app get my-webapp-dev

# Sync application manually if needed
argocd app sync my-webapp-dev

# Watch sync progress
argocd app wait my-webapp-dev

  

🔄 Advanced GitOps Patterns for 2025

Modern GitOps implementations have evolved beyond basic sync operations. Here are the advanced patterns that enterprises are adopting in 2025:

• ApplicationSets: For managing multiple applications across different clusters and namespaces
• Sync Windows: Control when automatic syncs can occur to prevent disruptions during business hours
• Health Checks: Custom health assessments beyond standard Kubernetes readiness probes
• Pre/Post Sync Hooks: Execute scripts before or after synchronization for database migrations, etc.
• Multi-source Applications: Combine configurations from multiple Git repositories or Helm charts

Here's an example of ApplicationSet for multi-cluster deployment:

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: my-webapp-clusters
  namespace: argocd
spec:
  generators:
  - clusters:
      selector:
        matchLabels:
          type: production
  template:
    metadata:
      name: '{{name}}-my-webapp'
    spec:
      project: default
      source:
        repoURL: https://github.com/your-org/gitops-repo.git
        targetRevision: main
        path: apps/overlays/production
      destination:
        server: '{{server}}'
        namespace: my-webapp-prod
      syncPolicy:
        automated:
          prune: true
          selfHeal: true

  

🔒 Security Best Practices for GitOps

Security is paramount in GitOps workflows. Implement these essential security measures:

• RBAC Configuration: Fine-grained access control for ArgoCD users and applications
• Git Crypt or SOPS: Encrypt sensitive data in Git repositories
• Network Policies: Restrict communication between ArgoCD components
• Pod Security Standards: Enforce security contexts for all deployed pods
• Regular Auditing: Monitor and alert on configuration drift

Example RBAC configuration for development teams:

apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-rbac-cm
  namespace: argocd
data:
  policy.csv: |
    p, role:developer, applications, get, */*, allow
    p, role:developer, applications, sync, dev/*, allow
    p, role:developer, applications, override, dev/*, deny
    g, dev-team, role:developer
    
  scopes: '[groups]'

  

📊 Monitoring and Observability in GitOps

Comprehensive monitoring is essential for maintaining healthy GitOps workflows. Implement these monitoring strategies:

• ArgoCD Metrics: Export Prometheus metrics for sync status and application health
• Git Webhooks: Trigger alerts on repository changes and sync events
• Configuration Drift Detection: Monitor and alert when live state differs from Git state
• Performance Metrics: Track sync duration and resource utilization

Example Prometheus alerts for ArgoCD:

groups:
- name: argocd
  rules:
  - alert: ArgoCDAppOutOfSync
    expr: argocd_app_info{sync_status="OutOfSync"} == 1
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Application {{ $labels.name }} is out of sync"
      description: "Application {{ $labels.name }} has been out of sync for more than 5 minutes"
  
  - alert: ArgoCDAppSyncFailed
    expr: argocd_app_info{health_status="Degraded"} == 1
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "Application {{ $labels.name }} sync failed"
      description: "Application {{ $labels.name }} has been in degraded state for 2 minutes"

  

⚡ Key Takeaways

1. GitOps with ArgoCD and Kustomize provides a robust framework for declarative Kubernetes deployments
2. Kustomize eliminates configuration duplication through strategic overlays and patches
3. ArgoCD enables continuous synchronization and self-healing capabilities
4. Proper repository structure is crucial for scalable multi-environment management
5. Security practices like RBAC and secret encryption are non-negotiable in production
6. Monitoring and alerting ensure early detection of configuration drift and sync failures

💬 Found this article helpful? Please leave a comment below or share it with your network to help others learn! Have you implemented GitOps in your organization? Share your experiences and challenges in the comments section.

About LK-TECH Academy — Practical tutorials & explainers on software engineering, AI, and infrastructure. Follow for concise, hands-on guides.

Introduction to network automation with Python and Netmiko

Network automation involves automating the tasks of network devices such as switches, routers, and firewalls to improve efficiency and reduce errors. Python is a popular programming language used for network automation due to its simplicity and ease of use. Netmiko is a Python library used to automate network devices that support SSH connections.

In this article, we will provide an introduction to network automation with Python and Netmiko.

Setting up Python and Netmiko

To get started, you will need to install Python on your machine. You can download the latest version of Python from the official website (https://www.python.org/downloads/) and install it according to the installation instructions for your operating system.

Once you have installed Python, you can install Netmiko using pip, a Python package manager, by running the following command in your terminal:

pip install netmiko

Connecting to a Network Device with Netmiko

Netmiko supports various network devices such as Cisco, Juniper, and Arista. To connect to a network device using Netmiko, you will need to provide the IP address, username, and password of the device. For example, the following Python code connects to a Cisco switch using SSH and retrieves the device prompt:

from netmiko import ConnectHandler

device = {
    'device_type': 'cisco_ios',
    'ip': '192.168.0.1',
    'username': 'admin',
    'password': 'password',
}

connection = ConnectHandler(**device)

output = connection.find_prompt()

print(output)

Executing Commands on a Network Device

Once you have established a connection to a network device, you can execute commands on it using Netmiko. For example, the following Python code executes the show interfaces command on a Cisco switch and retrieves the output:

output = connection.send_command('show interfaces')

print(output)

You can also execute multiple commands on a network device using the send_config_set method. For example, the following Python code configures the interface speed and duplex of a Cisco switch:

config_commands = [
    'interface GigabitEthernet0/1',
    'speed 100',
    'duplex full',
]

output = connection.send_config_set(config_commands)

print(output)

Automating Network Tasks with Netmiko and Python

Netmiko and Python can be used to automate various network tasks such as device configuration, backup, and monitoring. For example, the following Python code configures the VLANs on a Cisco switch based on a YAML configuration file:

import yaml

with open('vlans.yml', 'r') as f:
    vlans = yaml.safe_load(f)

config_commands = []
for vlan_id, vlan_name in vlans.items():
    config_commands.append(f'vlan {vlan_id}')
    config_commands.append(f'name {vlan_name}')

output = connection.send_config_set(config_commands)

print(output)

The vlans.yml configuration file contains the VLAN IDs and names:

vlan1: default
vlan10: servers
vlan20: users

Building a serverless CI/CD pipeline with Python and AWS Lambda

Building a serverless CI/CD pipeline with Python and AWS Lambda can improve the speed and efficiency of your software development process. In this article, we will discuss how to build a serverless CI/CD pipeline using Python and AWS Lambda.

The components required for building a serverless CI/CD pipeline with Python and AWS Lambda include:

• AWS CodeCommit for source code management
• AWS CodeBuild for building and testing code
• AWS Lambda for automating the pipeline
• AWS CodePipeline for continuous delivery
• AWS CloudFormation for infrastructure deployment

import boto3
import json

def lambda_handler(event, context):
    codepipeline = boto3.client('codepipeline')
    try:
        response = codepipeline.start_pipeline_execution(name='my-pipeline')
        return {
            'statusCode': 200,
            'body': json.dumps('Pipeline execution started')
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps(str(e))
        }

Prerequisites

Before we begin, make sure you have Python installed on your system. You can download Python from the official website at https://www.python.org/downloads/. We will also be using some Python packages, so make sure you have the following packages installed:

pip: The package installer for Python.

virtualenv: A tool that creates isolated Python environments.

Setting up a Virtual Environment

The first step in getting started with Python DevOps automation is to set up a virtual environment. A virtual environment allows you to create a separate environment for your Python project, which can help avoid conflicts with other packages on your system.

To create a virtual environment, open a terminal or command prompt and navigate to the directory where you want to create your project. Then, run the following commands:

python3 -m venv myproject
source myproject/bin/activate

This will create a new virtual environment called myproject and activate it.

Installing Packages

Now that we have our virtual environment set up, we can install the packages we need for our project. In this example, we will install the requests package, which allows us to send HTTP requests from our Python code. To install the package, run the following command:

pip install requests

Writing a Simple Script

With our virtual environment and packages set up, we can now write a simple Python script to automate a task. In this example, we will write a script that sends an HTTP GET request to a website and prints the response.

Create a new file called get_request.py and add the following code:

import requests

url = 'https://www.example.com'
response = requests.get(url)

print(response.text)

Save the file and run it with the following command:

python get_request.py

This will send an HTTP GET request to https://www.example.com and print the response.

How to use Python for configuration management with Ansible

Ansible is an open-source configuration management tool that allows you to automate the provisioning, configuration, and deployment of servers and applications. Python is the language that Ansible is built upon, making it a natural choice for writing Ansible modules and playbooks. In this article, we will cover how to use Python for configuration management with Ansible.

Prerequisites

Before we begin, make sure you have Ansible installed on your system. You can install Ansible using pip:

pip install ansible

Ansible Modules

Ansible modules are reusable pieces of code that can be used to perform specific tasks, such as installing a package or configuring a service. Ansible comes with many built-in modules, but you can also create your own custom modules using Python.

To create a custom module, you need to create a Python file with a function that performs the task you want. The function should take parameters as input and return a JSON object as output. Here is an example of a custom module that installs a package using apt:

import subprocess
import json

def install_package(package_name):
    result = {}
    cmd = ['apt-get', 'install', '-y', package_name]
    output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
    result['msg'] = 'Package installed successfully'
    result['output'] = output.decode('utf-8')
    return json.dumps(result)

Save this file as install_package.py in the directory where you want to run your Ansible playbook.

Ansible Playbooks

An Ansible playbook is a YAML file that defines a set of tasks to be executed on a set of hosts. Each task is defined as a module with parameters that define how the task should be performed. In the playbook, you can use the custom Python module we created earlier.

Here is an example of a playbook that installs a package using our custom module:

---
- name: Install package
  hosts: all
  become: true
  tasks:
    - name: Install package
      module: install_package
      args:
        package_name: nginx

Save this file as install_package.yml in the same directory as your custom Python module.

To run the playbook, use the following command:

ansible-playbook install_package.yml

This will run the playbook on all hosts defined in your Ansible inventory file.

Writing CI/CD pipelines with Python scripts and Jenkins

Jenkins is a popular open-source automation server that can be used to implement continuous integration and continuous delivery (CI/CD) pipelines. Python is a versatile language that can be used to write scripts to automate various tasks in the CI/CD pipeline. In this article, we will cover how to write CI/CD pipelines with Python scripts and Jenkins.

Prerequisites

Before we begin, make sure you have Jenkins installed on your system. You can download Jenkins from the official website at https://www.jenkins.io/download/. We will also be using some Python packages, so make sure you have the following packages installed:

pip: The package installer for Python.

virtualenv: A tool that creates isolated Python environments.

Setting up a Virtual Environment

The first step in writing CI/CD pipelines with Python scripts and Jenkins is to set up a virtual environment. A virtual environment allows you to create a separate environment for your Python project, which can help avoid conflicts with other packages on your system.

To create a virtual environment, open a terminal or command prompt and navigate to the directory where you want to create your project. Then, run the following commands:

python3 -m venv myproject
source myproject/bin/activate

This will create a new virtual environment called myproject and activate it.

Installing Packages

Now that we have our virtual environment set up, we can install the packages we need for our project. In this example, we will install the pytest package, which allows us to write and run tests in Python. To install the package, run the following command:

pip install pytest

Writing Python Scripts

With our virtual environment and packages set up, we can now write Python scripts to automate tasks in the CI/CD pipeline. In this example, we will write a script that runs tests using pytest.

Create a new file called test.py and add the following code:

import pytest

def test_example():
    assert 1 + 1 == 2

Save the file and run it with the following command:

pytest test.py

This will run the test and print the results.

Configuring Jenkins

Now that we have our Python script, we can configure Jenkins to run it as part of a CI/CD pipeline.

• Open Jenkins in your web browser and click on "New Item" to create a new project.
• Enter a name for your project and select "Freestyle project" as the project type.
• In the "Source Code Management" section, select your version control system and enter the repository URL.
• In the "Build" section, click on "Add build step" and select "Execute shell".
• In the "Command" field, enter the following command:

source /path/to/venv/bin/activate && pytest /path/to/test.py

pip install psutil

import psutil

# Get CPU usage
cpu_percent = psutil.cpu_percent()

# Get memory usage
memory = psutil.virtual_memory()
memory_percent = memory.percent

import logging

logger = logging.getLogger(__name__)

logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

import logging

logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)

logger.addHandler(file_handler)

logger.info('This is a log message')

2022-03-05 15:34:55,123 - __main__ - INFO - This is a log message

provider "aws" {
  region = "us-west-2"
}

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

terraform init

pip install python-terraform

import terraform

tf = terraform.Terraform(working_dir='./terraform')

tf.init()
tf.apply()

output = tf.output('public_ip')

print(output)

buckets = ['bucket1', 'bucket2', 'bucket3']

tf_code = """
provider "aws" {
  region = "us-west-2"
}

{}

"""

bucket_code = """
resource "aws_s3_bucket" "{}" {{
  bucket = "{}"
}}
"""

bucket_configs = [bucket_code.format(name, name) for name in buckets]

full_code = tf_code.format('\n'.join(bucket_configs))

with open('s3.tf', 'w') as f:
  f.write(full_code)

provider "aws" {
  region = "us-west-2"
}

resource "aws_s3_bucket" "bucket1" {
  bucket = "bucket1"
}

resource "aws_s3_bucket" "bucket2" {
  bucket = "bucket2"
}

resource "aws_s3_bucket" "bucket3" {
  bucket =

Please continue reading DevOps automation using Python - Part 2