Python untuk devops

Berikut ialah beberapa modul Python penting yang digunakan untuk automasi DevOps:

modul os: Modul os menyediakan cara untuk berinteraksi dengan sistem pengendalian, termasuk operasi fail, pengurusan proses dan maklumat sistem.

Modul Permintaan dan urllib3: Modul Permintaan dan urllib3 digunakan untuk menghantar permintaan HTTP dan mengendalikan respons HTTP.

Modul pengelogan: Modul pengelogan menyediakan cara untuk mengelog mesej daripada aplikasi Python.

modul boto3: Modul boto3 menyediakan antara muka kepada Amazon Web Services (AWS) SDK untuk Python.

modul paramiko : Modul paramiko ialah pelaksanaan Python bagi protokol SSH, digunakan untuk sambungan jauh yang selamat.

Modul JSON : Modul JSON digunakan untuk mengekod dan menyahkod data JSON.

Modul PyYAML : Modul PyYAML menyediakan cara untuk menghuraikan dan menjana data YAML.

modul panda: Modul panda menyediakan alat analisis data, termasuk manipulasi data dan visualisasi data.

modul smtplib: Modul smtplib menyediakan cara untuk menghantar mesej e-mel daripada aplikasi Python.

Kes Penggunaan Python dalam DevOps

1.Automasi Penyediaan Infrastruktur

• Peralatan: AWS Boto3, Azure SDK, Terraform, Ansible
• Contoh: Mengautomasikan penciptaan dan pengurusan sumber awan seperti tika EC2, baldi S3 dan pangkalan data RDS. Skrip Python boleh menggunakan pustaka AWS Boto3 untuk mengurus sumber AWS secara pengaturcaraan.

contoh kod:

import boto3

def lambda_handler(event, context):
    ec2 = boto3.client('ec2')

    # Get all EBS snapshots
    response = ec2.describe_snapshots(OwnerIds=['self'])

    # Get all active EC2 instance IDs
    instances_response = ec2.describe_instances(Filters=[{'Name': 'instance-state-name', 'Values': ['running']}])
    active_instance_ids = set()

    for reservation in instances_response['Reservations']:
        for instance in reservation['Instances']:
            active_instance_ids.add(instance['InstanceId'])

    # Iterate through each snapshot and delete if it's not attached to any volume or the volume is not attached to a running instance
    for snapshot in response['Snapshots']:
        snapshot_id = snapshot['SnapshotId']
        volume_id = snapshot.get('VolumeId')

        if not volume_id:
            # Delete the snapshot if it's not attached to any volume
            ec2.delete_snapshot(SnapshotId=snapshot_id)
            print(f"Deleted EBS snapshot {snapshot_id} as it was not attached to any volume.")
        else:
            # Check if the volume still exists
            try:
                volume_response = ec2.describe_volumes(VolumeIds=[volume_id])
                if not volume_response['Volumes'][0]['Attachments']:
                    ec2.delete_snapshot(SnapshotId=snapshot_id)
                    print(f"Deleted EBS snapshot {snapshot_id} as it was taken from a volume not attached to any running instance.")
            except ec2.exceptions.ClientError as e:
                if e.response['Error']['Code'] == 'InvalidVolume.NotFound':
                    # The volume associated with the snapshot is not found (it might have been deleted)
                    ec2.delete_snapshot(SnapshotId=snapshot_id)
                    print(f"Deleted EBS snapshot {snapshot_id} as its associated volume was not found.")

repo:https://github.com/PRATIKNALAWADE/AWS-Cost-Optimization/blob/main/ebs_snapshots.py

2.Kes Penggunaan: Mengautomasikan Talian Paip CI/CD dengan Python

Dalam saluran paip CI/CD, automasi adalah kunci untuk memastikan perubahan kod dibina, diuji dan digunakan secara konsisten dan boleh dipercayai. Python boleh digunakan untuk berinteraksi dengan alatan CI/CD seperti Jenkins, GitLab CI atau CircleCI, sama ada dengan mencetuskan kerja, mengendalikan acara webhook atau berinteraksi dengan pelbagai API untuk menggunakan aplikasi.

Di bawah ialah contoh cara anda boleh menggunakan Python untuk mengautomasikan aspek tertentu saluran paip CI/CD menggunakan Jenkins.

Contoh: Mencetuskan Jenkins Jobs dengan Python

Senario:
Anda mempunyai skrip Python yang perlu mencetuskan tugas Jenkins apabila komit baharu ditolak ke cawangan utama repositori GitHub. Skrip juga akan menghantar beberapa parameter kepada tugas Jenkins, seperti ID komit Git dan nama cawangan.

Langkah 1: Sediakan Jenkins Job

Pertama, pastikan anda mempunyai tugas Jenkins yang dikonfigurasikan untuk menerima parameter. Anda memerlukan nama kerja, URL Jenkins dan token API untuk pengesahan.

Langkah 2: Menulis Skrip Python

Di bawah ialah skrip Python yang mencetuskan tugas Jenkins dengan parameter tertentu:

import requests
import json

# Jenkins server details
jenkins_url = 'http://your-jenkins-server.com'
job_name = 'your-job-name'
username = 'your-username'
api_token = 'your-api-token'

# Parameters to pass to the Jenkins job
branch_name = 'main'
commit_id = 'abc1234def5678'

# Construct the job URL
job_url = f'{jenkins_url}/job/{job_name}/buildWithParameters'

# Define the parameters to pass
params = {
    'BRANCH_NAME': branch_name,
    'COMMIT_ID': commit_id
}

# Trigger the Jenkins job
response = requests.post(job_url, auth=(username, api_token), params=params)

# Check the response
if response.status_code == 201:
    print('Jenkins job triggered successfully.')
else:
    print(f'Failed to trigger Jenkins job: {response.status_code}, {response.text}')

Langkah 3: Penerangan

• Butiran Jenkins:

  • jenkins_url: URL pelayan Jenkins anda.
  • job_name: Nama kerja Jenkins yang anda ingin cetuskan.
  • nama pengguna dan api_token: Bukti kelayakan Jenkins anda untuk pengesahan.

• Parameter:

  • branch_name dan commit_id ialah contoh parameter yang akan digunakan oleh kerja Jenkins. Ini boleh dihantar secara dinamik berdasarkan aliran kerja CI/CD anda.

• Permintaan Perpustakaan:

  • Skrip menggunakan perpustakaan permintaan Python untuk membuat permintaan POST kepada pelayan Jenkins untuk mencetuskan tugas.
  • auth=(nama pengguna, api_token) digunakan untuk mengesahkan dengan API Jenkins.

• Pengendalian Respons:

  • Jika tugas berjaya dicetuskan, Jenkins membalas dengan kod status 201, yang akan disemak oleh skrip untuk mengesahkan kejayaan.

Langkah 4: Sepadukan dengan GitHub Webhooks

Untuk mencetuskan skrip Python ini secara automatik apabila komit baharu ditolak ke cawangan utama, anda boleh mengkonfigurasi webhook GitHub yang menghantar permintaan POST ke pelayan anda (di mana skrip Python ini dijalankan) setiap kali peristiwa tolak berlaku.

• Konfigurasi Webhook GitHub:

  1. Go to your GitHub repository settings.
  2. Under "Webhooks," click "Add webhook."
  3. Set the "Payload URL" to the URL of your server that runs the Python script.
  4. Choose application/json as the content type.
  5. Set the events to listen for (e.g., push events).
  6. Save the webhook.

• Handling the Webhook:

  • You may need to set up a simple HTTP server using Flask, FastAPI, or a similar framework to handle the incoming webhook requests from GitHub and trigger the Jenkins job accordingly.

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

# Jenkins server details
jenkins_url = 'http://your-jenkins-server.com'
job_name = 'your-job-name'
username = 'your-username'
api_token = 'your-api-token'

@app.route('/webhook', methods=['POST'])
def github_webhook():
    payload = request.json

    # Extract branch name and commit ID from the payload
    branch_name = payload['ref'].split('/')[-1]  # Get the branch name
    commit_id = payload['after']

    # Only trigger the job if it's the main branch
    if branch_name == 'main':
        job_url = f'{jenkins_url}/job/{job_name}/buildWithParameters'
        params = {
            'BRANCH_NAME': branch_name,
            'COMMIT_ID': commit_id
        }

        response = requests.post(job_url, auth=(username, api_token), params=params)

        if response.status_code == 201:
            return jsonify({'message': 'Jenkins job triggered successfully.'}), 201
        else:
            return jsonify({'message': 'Failed to trigger Jenkins job.'}), response.status_code

    return jsonify({'message': 'No action taken.'}), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Step 5: Deploying the Flask App

Deploy this Flask app on a server and ensure it is accessible via the public internet, so GitHub's webhook can send data to it.

Conclusion

This example illustrates how Python can be integrated into a CI/CD pipeline, interacting with tools like Jenkins to automate essential tasks.

3.Configuration Management and Orchestration

• Tooling: Ansible, Chef, Puppet
• Example: Using Python scripts with Ansible to manage the configuration of servers. Scripts can be used to ensure that all servers are configured consistently and to manage complex deployments that require orchestration of multiple services.

In this example, we'll use Python to manage server configurations with Ansible. The script will run Ansible playbooks to ensure servers are configured consistently and orchestrate the deployment of multiple services.

Example: Automating Server Configuration with Ansible and Python

Scenario:
You need to configure a set of servers to ensure they have the latest version of a web application, along with necessary dependencies and configurations. You want to use Ansible for configuration management and Python to trigger and manage Ansible playbooks.

Step 1: Create Ansible Playbooks

playbooks/setup.yml:
This Ansible playbook installs necessary packages and configures the web server.

---
- name: Configure web servers
  hosts: web_servers
  become: yes
  tasks:
    - name: Install nginx
      apt:
        name: nginx
        state: present

    - name: Deploy web application
      copy:
        src: /path/to/local/webapp
        dest: /var/www/html/webapp
        owner: www-data
        group: www-data
        mode: '0644'

    - name: Ensure nginx is running
      service:
        name: nginx
        state: started
        enabled: yes

inventory/hosts:
Define your servers in the Ansible inventory file.

[web_servers]
server1.example.com
server2.example.com

Step 2: Write the Python Script

The Python script will use the subprocess module to run Ansible commands and manage playbook execution.

import subprocess

def run_ansible_playbook(playbook_path, inventory_path):
    """
    Run an Ansible playbook using the subprocess module.

    :param playbook_path: Path to the Ansible playbook file.
    :param inventory_path: Path to the Ansible inventory file.
    :return: None
    """
    try:
        result = subprocess.run(
            ['ansible-playbook', '-i', inventory_path, playbook_path],
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        print('Ansible playbook executed successfully.')
        print(result.stdout)
    except subprocess.CalledProcessError as e:
        print('Ansible playbook execution failed.')
        print(e.stderr)

if __name__ == '__main__':
    # Paths to the playbook and inventory files
    playbook_path = 'playbooks/setup.yml'
    inventory_path = 'inventory/hosts'

    # Run the Ansible playbook
    run_ansible_playbook(playbook_path, inventory_path)

Step 3: Explanation

• Ansible Playbook (setup.yml):

  • Tasks: This playbook installs Nginx, deploys the web application, and ensures Nginx is running.
  • Hosts: web_servers is a group defined in the inventory file.

• Inventory File (hosts):

  • Groups: Defines which servers are part of the web_servers group.

• Python Script (run_ansible_playbook function):

  • subprocess.run: Executes the ansible-playbook command to apply configurations defined in the playbook.
  • Error Handling: Catches and prints errors if the playbook execution fails.

Step 4: Running the Script

• Make sure Ansible is installed on the system where the Python script is running.
• Ensure the ansible-playbook command is accessible in the system PATH.
• Execute the Python script to apply the Ansible configurations:

python3 your_script_name.py

Step 5: Advanced Use Cases

• Dynamic Inventory: Use Python to generate dynamic inventory files based on real-time data from a database or an API.
• Role-based Configurations: Define more complex configurations using Ansible roles and use Python to manage role-based deployments.
• Notifications and Logging: Extend the Python script to send notifications (e.g., via email or Slack) or log detailed information about the playbook execution.

Conclusion

By integrating Python with Ansible, you can automate server configuration and orchestration tasks efficiently. Python scripts can manage and trigger Ansible playbooks, ensuring that server configurations are consistent and deployments are orchestrated seamlessly.

4 Monitoring and Alerting with Python

In a modern monitoring setup, you often need to collect metrics and logs from various services, analyze them, and push them to monitoring systems like Prometheus or Elasticsearch. Python can be used to gather and process this data, and set up automated alerts based on specific conditions.

Example: Collecting Metrics and Logs, and Setting Up Alerts

1. Collecting Metrics and Logs

Scenario:
You want to collect custom metrics and logs from your application and push them to Prometheus and Elasticsearch. Additionally, you'll set up automated alerts based on specific conditions.

Step 1: Collecting Metrics with Python and Prometheus

To collect and expose custom metrics from your application, you can use the prometheus_client library in Python.

Install prometheus_client:

pip install prometheus_client

Python Script to Expose Metrics (metrics_server.py):

from prometheus_client import start_http_server, Gauge
import random
import time

# Create a metric to track the number of requests
REQUESTS = Gauge('app_requests_total', 'Total number of requests processed by the application')

def process_request():
    """Simulate processing a request."""
    REQUESTS.inc()  # Increment the request count

if __name__ == '__main__':
    # Start up the server to expose metrics
    start_http_server(8000)  # Metrics will be available at http://localhost:8000/metrics

    # Simulate processing requests
    while True:
        process_request()
        time.sleep(random.uniform(0.5, 1.5))  # Simulate random request intervals

Step 2: Collecting Logs with Python and Elasticsearch

To push logs to Elasticsearch, you can use the elasticsearch Python client.

Install elasticsearch:

pip install elasticsearch

Python Script to Send Logs (log_collector.py):

from elasticsearch import Elasticsearch
import logging
import time

# Elasticsearch client setup
es = Elasticsearch([{'host': 'localhost', 'port': 9200}])
index_name = 'application-logs'

# Configure Python logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('log_collector')

def log_message(message):
    """Log a message and send it to Elasticsearch."""
    logger.info(message)
    es.index(index=index_name, body={'message': message, 'timestamp': time.time()})

if __name__ == '__main__':
    while True:
        log_message('This is a sample log message.')
        time.sleep(5)  # Log every 5 seconds

Step 3: Setting Up Alerts

To set up alerts, you need to define alerting rules based on the metrics and logs collected. Here’s an example of how you can configure alerts with Prometheus.

Prometheus Alerting Rules (prometheus_rules.yml):

groups:
- name: example_alerts
  rules:
  - alert: HighRequestRate
    expr: rate(app_requests_total[1m]) > 5
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "High request rate detected"
      description: "Request rate is above 5 requests per minute for the last 2 minutes."

Deploying Alerts:

1. Update Prometheus Configuration: Ensure that your Prometheus server is configured to load the alerting rules file. Update your prometheus.yml configuration file:

   rule_files:
     - 'prometheus_rules.yml'

1. Reload Prometheus Configuration: After updating the configuration, reload Prometheus to apply the new rules.

   kill -HUP $(pgrep prometheus)

Grafana Setup:

1. Add Prometheus as a Data Source:
   Go to Grafana's data source settings and add Prometheus.

2. Create Dashboards:
   Create dashboards in Grafana to visualize the metrics exposed by your application. You can set up alerts in Grafana as well, based on the metrics from Prometheus.

Elasticsearch Alerting:

1. Install Elastic Stack Alerting Plugin:
   If you're using Elasticsearch with Kibana, you can use Kibana's alerting features to create alerts based on log data. You can set thresholds and get notifications via email, Slack, or other channels.

2. Define Alert Conditions:
   Use Kibana to define alert conditions based on your log data indices.

Conclusion

By using Python scripts to collect and process metrics and logs, and integrating them with tools like Prometheus and Elasticsearch, you can create a robust monitoring and alerting system. The examples provided show how to expose custom metrics, push logs, and set up alerts for various conditions. This setup ensures you can proactively monitor your application, respond to issues quickly, and maintain system reliability.

5. Use Case: Scripting for Routine Tasks and Maintenance

Routine maintenance tasks like backups, system updates, and log rotation are essential for keeping your infrastructure healthy. You can automate these tasks using Python scripts and schedule them with cron jobs. Below are examples of Python scripts for common routine maintenance tasks and how to set them up with cron.

Example: Python Scripts for Routine Tasks

1. Backup Script

Scenario:
Create a Python script to back up a directory to a backup location. This script will be scheduled to run daily to ensure that your data is regularly backed up.

Backup Script (backup_script.py):

import shutil
import os
from datetime import datetime

# Define source and backup directories
source_dir = '/path/to/source_directory'
backup_dir = '/path/to/backup_directory'

# Create a timestamped backup file name
timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
backup_file = f'{backup_dir}/backup_{timestamp}.tar.gz'

def create_backup():
    """Create a backup of the source directory."""
    shutil.make_archive(backup_file.replace('.tar.gz', ''), 'gztar', source_dir)
    print(f'Backup created at {backup_file}')

if __name__ == '__main__':
    create_backup()

2. System Update Script

Scenario:
Create a Python script to update the system packages. This script will ensure that the system is kept up-to-date with the latest security patches and updates.

System Update Script (system_update.py):

import subprocess

def update_system():
    """Update the system packages."""
    try:
        subprocess.run(['sudo', 'apt-get', 'update'], check=True)
        subprocess.run(['sudo', 'apt-get', 'upgrade', '-y'], check=True)
        print('System updated successfully.')
    except subprocess.CalledProcessError as e:
        print(f'Failed to update the system: {e}')

if __name__ == '__main__':
    update_system()

3. Log Rotation Script

Scenario:
Create a Python script to rotate log files, moving old logs to an archive directory and compressing them.

Log Rotation Script (log_rotation.py):

import os
import shutil
from datetime import datetime

# Define log directory and archive directory
log_dir = '/path/to/log_directory'
archive_dir = '/path/to/archive_directory'

def rotate_logs():
    """Rotate log files by moving and compressing them."""
    for log_file in os.listdir(log_dir):
        log_path = os.path.join(log_dir, log_file)
        if os.path.isfile(log_path):
            timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
            archive_file = f'{archive_dir}/{log_file}_{timestamp}.gz'
            shutil.copy(log_path, archive_file)
            shutil.make_archive(archive_file.replace('.gz', ''), 'gztar', root_dir=archive_dir, base_dir=log_file)
            os.remove(log_path)
            print(f'Log rotated: {archive_file}')

if __name__ == '__main__':
    rotate_logs()

Setting Up Cron Jobs

You need to set up cron jobs to schedule these scripts to run at specific intervals. Use the crontab command to edit the cron schedule.

1. Open the Crontab File:

   crontab -e

1. Add Cron Job Entries:

• Daily Backup at 2 AM:
  

   0 2 * * * /usr/bin/python3 /path/to/backup_script.py
  

• Weekly System Update on Sunday at 3 AM:
  

   0 3 * * 0 /usr/bin/python3 /path/to/system_update.py
  

• Log Rotation Every Day at Midnight:
  

   0 0 * * * /usr/bin/python3 /path/to/log_rotation.py
  

Explanation:

• 0 2 * * *: Runs the script at 2:00 AM every day.
• 0 3 * * 0: Runs the script at 3:00 AM every Sunday.
• 0 0 * * *: Runs the script at midnight every day.

Conclusion

Using Python scripts for routine tasks and maintenance helps automate critical processes such as backups, system updates, and log rotation. By scheduling these scripts with cron jobs, you ensure that these tasks are performed consistently and without manual intervention. This approach enhances the reliability and stability of your infrastructure, keeping it healthy and up-to-date.

Atas ialah kandungan terperinci Python untuk devops. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!