Ejercicio: Laravel con AWS CodeArtifact y Pipeline CI/CD ​

# scripts/setup-env.py
import boto3
import json

class EnvironmentManager:
    def __init__(self, environment):
        self.ssm = boto3.client('ssm')
        self.environment = environment
        self.app_name = "laravel-aws-app"
        
    def set_parameters(self, config):
        """Guarda parámetros en Parameter Store"""
        for key, value in config.items():
            parameter_name = f"/{self.app_name}/{self.environment}/{key}"
            self.ssm.put_parameter(
                Name=parameter_name,
                Value=value,
                Type='SecureString',
                Overwrite=True,
                Tags=[
                    {
                        'Key': 'Environment',
                        'Value': self.environment
                    },
                    {
                        'Key': 'Application',
                        'Value': self.app_name
                    }
                ]
            )
            
    def get_parameters(self):
        """Obtiene todos los parámetros para el entorno"""
        prefix = f"/{self.app_name}/{self.environment}/"
        params = {}
        
        paginator = self.ssm.get_paginator('get_parameters_by_path')
        for page in paginator.paginate(
            Path=prefix,
            Recursive=True,
            WithDecryption=True
        ):
            for param in page['Parameters']:
                name = param['Name'].replace(prefix, '')
                params[name] = param['Value']
                
        return params
        
    def load_env_file(self, env_file='.env.example'):
        """Carga variables desde archivo .env"""
        config = {}
        with open(env_file, 'r') as f:
            for line in f:
                if '=' in line and not line.startswith('#'):
                    key, value = line.strip().split('=', 1)
                    config[key] = value
        return config

# Uso
if __name__ == "__main__":
    environments = ['dev', 'stg', 'prod']
    
    for env in environments:
        manager = EnvironmentManager(env)
        
        # Cargar configuración base
        base_config = manager.load_env_file('src/.env.example')
        
        # Personalizar por entorno
        if env == 'prod':
            base_config.update({
                'APP_DEBUG': 'false',
                'APP_ENV': 'production',
                'LOG_LEVEL': 'error'
            })
        elif env == 'stg':
            base_config.update({
                'APP_DEBUG': 'false',
                'APP_ENV': 'staging',
                'LOG_LEVEL': 'debug'
            })
        else:  # dev
            base_config.update({
                'APP_DEBUG': 'true',
                'APP_ENV': 'development',
                'LOG_LEVEL': 'debug'
            })
            
        # Guardar en Parameter Store
        manager.set_parameters(base_config)

# scripts/pipeline/build_validator.py
import boto3
import time

class BuildValidator:
    def __init__(self, project_name, environment):
        self.codebuild = boto3.client('codebuild')
        self.project_name = project_name
        self.environment = environment
        
    def validate_build(self, build_id):
        """Valida el estado de un build"""
        while True:
            response = self.codebuild.batch_get_builds(ids=[build_id])
            build = response['builds'][0]
            status = build['buildStatus']
            
            if status == 'SUCCEEDED':
                print(f"Build completado exitosamente: {build_id}")
                return True
            elif status in ['FAILED', 'FAULT', 'STOPPED', 'TIMED_OUT']:
                print(f"Build falló: {build_id}")
                print(f"Fase: {build.get('currentPhase')}")
                print(f"Error: {build.get('failureMessage', 'No error message')}")
                return False
                
            print(f"Build en progreso... Estado: {status}")
            time.sleep(30)
            
    def get_build_logs(self, build_id):
        """Obtiene los logs del build"""
        response = self.codebuild.batch_get_builds(ids=[build_id])
        build = response['builds'][0]
        
        logs = {
            'build_id': build_id,
            'project': self.project_name,
            'environment': self.environment,
            'status': build['buildStatus'],
            'start_time': build['startTime'].isoformat(),
            'end_time': build.get('endTime', '').isoformat() if build.get('endTime') else None,
            'phases': []
        }
        
        for phase in build['phases']:
            phase_info = {
                'phase_name': phase['phaseType'],
                'status': phase.get('phaseStatus', 'IN_PROGRESS'),
                'duration': phase.get('durationInSeconds'),
                'messages': phase.get('contextMessages', [])
            }
            logs['phases'].append(phase_info)
            
        return logs

# scripts/database/restore.py
import boto3
import click
import time

class DatabaseRestorer:
    def __init__(self, environment):
        self.rds = boto3.client('rds')
        self.s3 = boto3.client('s3')
        self.environment = environment
        self.app_name = 'laravel-aws-app'

    def restore_from_snapshot(self, snapshot_id, new_instance_id):
        """Restaura desde un snapshot de RDS"""
        try:
            response = self.rds.restore_db_instance_from_db_snapshot(
                DBInstanceIdentifier=new_instance_id,
                DBSnapshotIdentifier=snapshot_id,
                AutoMinorVersionUpgrade=True,
                CopyTagsToSnapshot=True,
                PubliclyAccessible=False
            )
            
            self._wait_for_instance(new_instance_id)
            return True
        except Exception as e:
            print(f"Error restoring from snapshot: {str(e)}")
            return False

    def restore_from_backup(self, backup_file, instance_id):
        """Restaura desde un backup lógico"""
        try:
            # Descargar backup
            self.s3.download_file(
                f'laravel-db-backups-{self.environment}',
                f'daily/{backup_file}',
                backup_file
            )
            
            # Descomprimir
            if backup_file.endswith('.gz'):
                import gzip
                with gzip.open(backup_file, 'rb') as f_in:
                    with open(backup_file[:-3], 'wb') as f_out:
                        f_out.write(f_in.read())
                backup_file = backup_file[:-3]
            
            # Obtener credenciales
            ssm = boto3.client('ssm')
            credentials = {
                'host': self._get_parameter('DB_HOST'),
                'user': self._get_parameter('DB_USERNAME'),
                'password': self._get_parameter('DB_PASSWORD'),
                'database': self._get_parameter('DB_DATABASE')
            }
            
            # Restaurar
            import subprocess
            cmd = f"mysql -h{credentials['host']} -u{credentials['user']} -p{credentials['password']} {credentials['database']} < {backup_file}"
            subprocess.run(cmd, shell=True, check=True)
            
            return True
        except Exception as e:
            print(f"Error restoring from backup: {str(e)}")
            return False

    def _wait_for_instance(self, instance_id):
        """Espera a que la instancia esté disponible"""
        while True:
            response = self.rds.describe_db_instances(
                DBInstanceIdentifier=instance_id
            )
            status = response['DBInstances'][0]['DBInstanceStatus']
            
            if status == 'available':
                break
            
            print(f"Waiting for instance... Status: {status}")
            time.sleep(30)

    def _get_parameter(self, param_name):
        """Obtiene parámetro de SSM"""
        ssm = boto3.client('ssm')
        response = ssm.get_parameter(
            Name=f"/{self.app_name}/{self.environment}/{param_name}",
            WithDecryption=True
        )
        return response['Parameter']['Value']

@click.command()
@click.option('--environment', required=True, type=click.Choice(['dev', 'stg', 'prod']))
@click.option('--snapshot-id', help='Snapshot ID for restoration')
@click.option('--backup-file', help='Backup file name for restoration')
@click.option('--instance-id', required=True, help='Target instance ID')
def restore(environment, snapshot_id, backup_file, instance_id):
    restorer = DatabaseRestorer(environment)
    
    if snapshot_id:
        success = restorer.restore_from_snapshot(snapshot_id, instance_id)
    elif backup_file:
        success = restorer.restore_from_backup(backup_file, instance_id)
    else:
        click.echo("Either snapshot-id or backup-file must be provided")
        return
    
    if success:
        click.echo("Restoration completed successfully")
    else:
        click.echo("Restoration failed")

if __name__ == '__main__':
    restore()