lambda_function.py

import json
from typing import Dict, Any

# Sample CV data
CV_DATA = {
    "personal_info": {
        "name": "John Smith",
        "title": "Senior DevOps Engineer",
        "email": "john.smith@example.com",
        "phone": "+1-555-0123",
        "location": "San Francisco, CA, USA",
        "linkedin": "https://linkedin.com/in/johnsmith",
        "github": "https://github.com/johnsmith",
        "website": "https://johnsmith.dev",
    },
    "summary": "Experienced DevOps Engineer with 6+ years specializing in cloud infrastructure, automation, and scalable systems. Proven track record of managing high-traffic applications serving millions of daily requests, delivering CI/CD pipelines and cloud migrations within strict deadlines, and architecting both cloud solutions and on-premises infrastructure in fast-paced environments.",
    "experience": [
        {
            "company": "TechCorp Solutions",
            "position": "Senior DevOps Engineer",
            "duration": "January 2022 - Present",
            "location": "San Francisco, CA",
            "description": "Lead DevOps initiatives for enterprise clients, managing cloud infrastructure and implementing automation solutions. Collaborate with development teams to optimize deployment pipelines and ensure system reliability.",
            "technologies": [
                "AWS",
                "Docker",
                "Kubernetes",
                "Terraform",
                "Jenkins",
                "Prometheus",
                "Grafana",
                "Python",
            ],
            "achievements": [
                "Reduced deployment time by 75% through automated CI/CD pipeline implementation",
                "Managed infrastructure serving 10+ million daily API requests with 99.9% uptime",
                "Led migration of legacy applications to cloud-native architecture",
                "Implemented comprehensive monitoring and alerting solutions",
            ],
        },
        {
            "company": "CloudTech Innovations",
            "position": "DevOps Engineer",
            "duration": "March 2020 - December 2021",
            "location": "Austin, TX",
            "description": "Designed and maintained cloud infrastructure for multiple client projects. Implemented Infrastructure as Code practices and automated deployment processes for various applications.",
            "technologies": [
                "AWS",
                "Azure",
                "Docker",
                "Ansible",
                "GitLab CI",
                "Terraform",
                "PostgreSQL",
            ],
            "achievements": [
                "Architected multi-region AWS infrastructure supporting 50+ microservices",
                "Implemented blue-green deployment strategy reducing downtime by 90%",
                "Automated infrastructure provisioning reducing setup time from days to hours",
                "Mentored junior engineers in DevOps best practices",
            ],
        },
        {
            "company": "StartupTech Inc",
            "position": "Systems Administrator",
            "duration": "June 2018 - February 2020",
            "location": "Seattle, WA",
            "description": "Managed on-premises and cloud infrastructure for growing startup. Responsible for system administration, backup solutions, and network management.",
            "technologies": [
                "Linux",
                "VMware",
                "AWS",
                "MySQL",
                "Nginx",
                "Python",
                "Bash",
            ],
            "achievements": [
                "Built scalable infrastructure supporting company growth from 10 to 100+ employees",
                "Implemented automated backup and disaster recovery procedures",
                "Optimized database performance resulting in 40% faster query response times",
                "Established monitoring and logging infrastructure using open-source tools",
            ],
        },
    ],
    "education": [
        {
            "institution": "State University of Technology",
            "degree": "Bachelor of Science in Computer Science",
            "duration": "2014 - 2018",
            "location": "California, USA",
            "gpa": "3.7/4.0",
        }
    ],
    "skills": {
        "cloud_platforms": ["AWS", "Azure", "Google Cloud Platform"],
        "containerization": ["Docker", "Kubernetes", "OpenShift"],
        "infrastructure_as_code": [
            "Terraform",
            "CloudFormation",
            "Pulumi",
            "ARM Templates",
        ],
        "ci_cd": ["Jenkins", "GitLab CI", "GitHub Actions", "Azure DevOps", "CircleCI"],
        "monitoring": ["Prometheus", "Grafana", "ELK Stack", "Datadog", "New Relic"],
        "configuration_management": ["Ansible", "Chef", "Puppet"],
        "programming_languages": ["Python", "Bash", "JavaScript", "Go", "PowerShell"],
        "databases": ["PostgreSQL", "MySQL", "MongoDB", "Redis", "DynamoDB"],
        "operating_systems": ["Linux (Ubuntu, CentOS, RHEL)", "Windows Server"],
        "networking": ["TCP/IP", "DNS", "Load Balancers", "VPN", "Firewalls"],
        "version_control": ["Git", "GitHub", "GitLab", "Bitbucket"],
        "collaboration_tools": ["Jira", "Confluence", "Slack", "Microsoft Teams"],
    },
    "projects": [
        {
            "name": "CV API",
            "description": "Serverless CV API built with AWS Lambda and API Gateway demonstrating modern cloud architecture",
            "technologies": [
                "Python",
                "AWS Lambda",
                "API Gateway",
                "SAM",
                "CloudFormation",
            ],
            "github": "https://github.com/johnsmith/cv-api",
            "highlights": [
                "Serverless architecture with auto-scaling capabilities",
                "RESTful API design with comprehensive endpoints",
                "Infrastructure as Code using AWS SAM",
                "Comprehensive unit testing and CI/CD pipeline",
            ],
        },
        {
            "name": "Infrastructure Automation Platform",
            "description": "Internal platform for automated infrastructure provisioning and management",
            "technologies": ["Python", "Terraform", "AWS", "React", "PostgreSQL"],
            "github": "https://github.com/johnsmith/infra-platform",
            "highlights": [
                "Reduced infrastructure provisioning time by 80%",
                "Self-service portal for development teams",
                "Automated compliance and security scanning",
                "Multi-cloud support with consistent APIs",
            ],
        },
        {
            "name": "Monitoring and Alerting Solution",
            "description": "Comprehensive monitoring solution for microservices architecture",
            "technologies": [
                "Prometheus",
                "Grafana",
                "AlertManager",
                "Kubernetes",
                "Helm",
            ],
            "github": "https://github.com/johnsmith/monitoring-stack",
            "highlights": [
                "Custom dashboards for business metrics",
                "Intelligent alerting with reduced false positives",
                "Multi-cluster monitoring capability",
                "Integration with incident response workflows",
            ],
        },
    ],
    "certifications": [
        {
            "name": "AWS Certified Solutions Architect - Professional",
            "issuer": "Amazon Web Services",
            "date": "2023",
            "credential_id": "AWS-PSA-12345",
        },
        {
            "name": "Certified Kubernetes Administrator (CKA)",
            "issuer": "Cloud Native Computing Foundation",
            "date": "2023",
            "credential_id": "CKA-67890",
        },
        {
            "name": "HashiCorp Certified: Terraform Associate",
            "issuer": "HashiCorp",
            "date": "2022",
            "credential_id": "HC-TA-54321",
        },
    ],
    "languages": [
        {"language": "English", "proficiency": "Native speaker"},
        {"language": "Spanish", "proficiency": "Conversational"},
    ],
    "key_achievements": [
        "Successfully architected and deployed infrastructure serving 10+ million daily requests",
        "Led cloud migration projects resulting in 60% cost reduction",
        "Implemented DevOps practices reducing deployment time from hours to minutes",
        "Maintained 99.9% uptime across critical production systems",
        "Mentored 15+ junior engineers in cloud technologies and DevOps practices",
        "Established security best practices reducing security incidents by 85%",
    ],
    "personal_interests": [
        "Open Source Contribution: Regular contributor to cloud-native projects",
        "Technology Blogging: Writing about DevOps trends and best practices",
        "Continuous Learning: Staying current with emerging cloud technologies",
        "Home Lab: Experimenting with new tools and technologies",
        "Community Speaking: Presenting at local tech meetups and conferences",
    ],
}


def lambda_handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:
    """
    AWS Lambda handler for Personal API
    """

    # CORS headers
    headers = {
        "Content-Type": "application/json",
        "Access-Control-Allow-Origin": "*",
        "Access-Control-Allow-Headers": "Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token",
        "Access-Control-Allow-Methods": "GET,OPTIONS",
    }

    try:
        # Handle CORS preflight request
        if event.get("httpMethod") == "OPTIONS":
            return {"statusCode": 200, "headers": headers, "body": ""}

        # Get the HTTP method and path
        http_method = event.get("httpMethod", "")
        path = event.get("path", "")
        query_parameters = event.get("queryStringParameters") or {}

        if http_method != "GET":
            return {
                "statusCode": 405,
                "headers": headers,
                "body": json.dumps({"error": "Method not allowed"}),
            }

        # Route handling
        if path == "/cv" or path == "/":
            # Return full CV
            response_data = CV_DATA

        elif path == "/cv/personal":
            # Return personal information only
            response_data = CV_DATA["personal_info"]

        elif path == "/cv/experience":
            # Return work experience
            response_data = CV_DATA["experience"]

        elif path == "/cv/education":
            # Return education
            response_data = CV_DATA["education"]

        elif path == "/cv/skills":
            # Return skills
            response_data = CV_DATA["skills"]

        elif path == "/cv/projects":
            # Return projects
            response_data = CV_DATA["projects"]

        elif path == "/cv/summary":
            # Return summary
            response_data = {"summary": CV_DATA["summary"]}

        elif path == "/cv/certifications":
            # Return certifications
            response_data = CV_DATA["certifications"]

        elif path == "/cv/languages":
            # Return languages
            response_data = CV_DATA["languages"]

        elif path == "/cv/achievements":
            # Return key achievements
            response_data = CV_DATA["key_achievements"]

        elif path == "/cv/interests":
            # Return personal interests
            response_data = CV_DATA["personal_interests"]

        elif path.startswith("/cv/search"):
            # Search functionality
            search_term = query_parameters.get("q", "").lower()
            if not search_term:
                return {
                    "statusCode": 400,
                    "headers": headers,
                    "body": json.dumps(
                        {"error": "Search term required. Use ?q=keyword"}
                    ),
                }

            # Search through CV data
            results = search_cv(search_term)
            response_data = {"search_term": search_term, "results": results}

        else:
            return {
                "statusCode": 404,
                "headers": headers,
                "body": json.dumps({"error": "Endpoint not found"}),
            }

        return {
            "statusCode": 200,
            "headers": headers,
            "body": json.dumps(response_data, indent=2),
        }

    except Exception as e:
        print(f"Error: {str(e)}")  # CloudWatch logs
        return {
            "statusCode": 500,
            "headers": headers,
            "body": json.dumps({"error": "Internal server error"}),
        }


def search_cv(search_term: str) -> Dict[str, Any]:
    """Search through CV data - ultra-simple version"""
    results = {}

    # Convert entire CV to searchable text and check each section
    for section_name, section_data in CV_DATA.items():
        if section_name == "personal_info":
            continue  # Skip personal info from search

        section_text = json.dumps(section_data, default=str).lower()
        if search_term in section_text:
            results[section_name] = section_data

    return results