Tren Teknologi Cloud

import json
import boto3
import psutil
import time
from datetime import datetime
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class EdgeDevice:
    def __init__(self, thing_name, iot_client):
        self.thing_name = thing_name
        self.iot_client = iot_client
        self.gg_client = boto3.client('greengrassv2')

    def create_thing(self):
        """Create IoT Thing for edge device"""
        try:
            response = self.iot_client.create_thing(
                thingName=self.thing_name
            )
            logger.info(f"Created IoT Thing: {self.thing_name}")
            return response
        except Exception as e:
            logger.error(f"Error creating thing: {e}")
            raise

    def create_certificates(self):
        """Create certificates for secure communication"""
        response = self.iot_client.create_keys_and_certificate(
            setAsActive=True
        )
        certificate_arn = response['certificateArn']
        certificate_pem = response['certificatePem']
        private_key = response['keyPair']['PrivateKey']
        
        logger.info("Created IoT certificates")
        return certificate_arn, certificate_pem, private_key

    def deploy_greengrass_component(self, component_name):
        """Deploy Greengrass component to edge device"""
        try:
            response = self.gg_client.create_component_version(
                inlineRecipe=self.create_component_recipe(component_name)
            )
            logger.info(f"Deployed component: {component_name}")
            return response
        except Exception as e:
            logger.error(f"Error deploying component: {e}")
            raise

    def create_component_recipe(self, component_name):
        """Create component recipe for edge processing"""
        recipe = {
            "RecipeFormatVersion": "2020-01-25",
            "ComponentName": component_name,
            "ComponentVersion": "1.0.0",
            "ComponentDescription": "Edge data processing component",
            "ComponentPublisher": "EdgePlatform",
            "Manifests": [
                {
                    "Platform": {
                        "os": "linux"
                    },
                    "Lifecycle": {
                        "Install": "python3 -m pip install -r {artifacts:decompressedPath}/requirements.txt",
                        "Run": "python3 -u {artifacts:decompressedPath}/edge_processor.py"
                    },
                    "Artifacts": [
                        {
                            "URI": "s3://edge-components/{component_name}/v1.0.0/edge_processor.zip"
                        }
                    ]
                }
            ]
        }
        return json.dumps(recipe)

import json
import time
import logging
from typing import Dict, Any
import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import (
    QOS,
    PublishToIoTCoreRequest,
    SubscribeToTopicRequest,
    SubscriptionResponseMessage
)

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class EdgeDataProcessor:
    def __init__(self):
        self.ipc_client = awsiot.greengrasscoreipc.connect()
        self.telemetry_data = []
        self.anomaly_threshold = 2.5  # Standard deviations
        
    def process_sensor_data(self, sensor_data: Dict[str, Any]) -> Dict[str, Any]:
        """Process sensor data at the edge"""
        try:
            # Real-time anomaly detection
            processed_data = {
                'timestamp': sensor_data.get('timestamp'),
                'sensor_id': sensor_data.get('sensor_id'),
                'raw_value': sensor_data.get('value'),
                'processed_value': self.apply_filters(sensor_data.get('value')),
                'anomaly_detected': self.detect_anomaly(sensor_data.get('value')),
                'processing_location': 'edge'
            }
            
            # Only send critical data to cloud
            if processed_data['anomaly_detected']:
                self.publish_to_cloud(processed_data)
            
            return processed_data
            
        except Exception as e:
            logger.error(f"Error processing sensor data: {e}")
            return {}

    def apply_filters(self, value: float) -> float:
        """Apply digital filters for noise reduction"""
        # Simple moving average filter
        self.telemetry_data.append(value)
        if len(self.telemetry_data) > 10:
            self.telemetry_data.pop(0)
        
        return sum(self.telemetry_data) / len(self.telemetry_data)

    def detect_anomaly(self, value: float) -> bool:
        """Detect anomalies using statistical methods"""
        if len(self.telemetry_data) < 5:
            return False
            
        mean = sum(self.telemetry_data) / len(self.telemetry_data)
        variance = sum((x - mean) ** 2 for x in self.telemetry_data) / len(self.telemetry_data)
        std_dev = variance ** 0.5
        
        return abs(value - mean) > self.anomaly_threshold * std_dev

    def publish_to_cloud(self, data: Dict[str, Any]):
        """Publish processed data to AWS IoT Core"""
        try:
            request = PublishToIoTCoreRequest(
                topic_name='edge/processed/data',
                qos=QOS.AT_LEAST_ONCE,
                payload=json.dumps(data).encode()
            )
            self.ipc_client.publish_to_iot_core(request)
            logger.info("Published processed data to cloud")
        except Exception as e:
            logger.error(f"Error publishing to cloud: {e}")

    def run(self):
        """Main execution loop"""
        logger.info("Starting edge data processor...")
        
        while True:
            # Simulate sensor data processing
            sensor_data = {
                'timestamp': datetime.now().isoformat(),
                'sensor_id': 'temperature_sensor_001',
                'value': self.read_sensor_value(),
                'unit': 'celsius'
            }
            
            processed_data = self.process_sensor_data(sensor_data)
            logger.info(f"Processed data: {processed_data}")
            
            time.sleep(1)  # Process every second

if __name__ == "__main__":
    processor = EdgeDataProcessor()
    processor.run()

# AWS Outposts Configuration
resource "aws_outposts_outpost" "main" {
  name = "production-outpost"
  site_id = var.outpost_site_id
  
  tags = {
    Environment = var.environment
    Purpose     = "hybrid-workloads"
  }
}

# Outpost Subnet Configuration
resource "aws_subnet" "outpost" {
  vpc_id               = aws_vpc.main.id
  cidr_block           = var.outpost_subnet_cidr
  availability_zone    = "${var.aws_region}-outpost-1"
  outpost_arn          = aws_outposts_outpost.main.arn

  tags = {
    Name = "${var.cluster_name}-outpost-subnet"
  }
}

# Hybrid Load Balancer
resource "aws_lb" "hybrid" {
  name               = "${var.cluster_name}-hybrid-alb"
  internal           = false
  load_balancer_type = "application"
  
  subnets = [
    aws_subnet.public[0].id,
    aws_subnet.public[1].id,
    aws_subnet.outpost.id
  ]

  enable_deletion_protection = true

  tags = {
    Environment = var.environment
    Type        = "hybrid"
  }
}

# EC2 Instance pada Outpost
resource "aws_instance" "outpost_worker" {
  ami           = var.outpost_ami_id
  instance_type = "m5.large"
  subnet_id     = aws_subnet.outpost.id
  
  # Outpost-specific configuration
  outpost_arn = aws_outposts_outpost.main.arn

  vpc_security_group_ids = [aws_security_group.outpost.id]

  user_data = base64encode(templatefile("${path.module}/outpost-userdata.sh", {
    cluster_name = var.cluster_name
    region       = var.aws_region
  }))

  tags = {
    Name = "${var.cluster_name}-outpost-worker"
    Environment = var.environment
  }

  depends_on = [aws_outposts_outpost.main]
}

# Hybrid Data Sync Configuration
resource "aws_datasync_location_efs" "hybrid_sync" {
  efs_file_system_arn = aws_efs_file_system.main.arn

  ec2_config {
    security_group_arns = [aws_security_group.datasync.arn]
    subnet_arn         = aws_subnet.private[0].arn
  }

  tags = {
    Name = "hybrid-data-sync"
  }
}