awslabs.elasticache-mcp-server 0.1.1__py3-none-any.whl

awslabs/elasticache_mcp_server/tools/cc/connect.py

@@ -0,0 +1,444 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Connect module for creating and configuring jump host EC2 instances to access ElastiCache clusters."""
+
+from ...common.connection import EC2ConnectionManager, ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from botocore.exceptions import ClientError
+from typing import Any, Dict, Tuple, Union
+
+
+async def _configure_security_groups(
+    cache_cluster_id: str, instance_id: str, ec2_client: Any = None, elasticache_client: Any = None
+) -> Tuple[bool, str, int]:
+    """Configure security group rules to allow access from EC2 instance to ElastiCache cluster.
+
+    Args:
+        cache_cluster_id (str): ID of the ElastiCache cluster
+        instance_id (str): ID of the EC2 instance
+        ec2_client (Any, optional): EC2 client. If not provided, will get from connection manager
+        elasticache_client (Any, optional): ElastiCache client. If not provided, will get from connection manager
+
+    Returns:
+        Tuple[bool, str, int]: Tuple containing (success status, vpc id, cache port)
+
+    Raises:
+        ValueError: If VPC compatibility check fails or required resources not found
+    """
+    if not ec2_client:
+        ec2_client = EC2ConnectionManager.get_connection()
+    if not elasticache_client:
+        elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    # Get cache cluster details
+    cache_cluster = elasticache_client.describe_cache_clusters(
+        CacheClusterId=cache_cluster_id, ShowCacheNodeInfo=True
+    )['CacheClusters'][0]
+
+    # Get cache cluster VPC ID
+    cache_subnet_group = elasticache_client.describe_cache_subnet_groups(
+        CacheSubnetGroupName=cache_cluster['CacheSubnetGroupName']
+    )['CacheSubnetGroups'][0]
+    cache_vpc_id = cache_subnet_group['VpcId']
+
+    # Get cache cluster security groups
+    cache_security_groups = cache_cluster.get('SecurityGroups', [])
+    if not cache_security_groups:
+        raise ValueError(f'No security groups found for cache cluster {cache_cluster_id}')
+
+    # Get cache cluster port
+    cache_port = cache_cluster['CacheNodes'][0]['Endpoint']['Port']
+
+    # Get EC2 instance details
+    instance_info = ec2_client.describe_instances(InstanceIds=[instance_id])
+    if not instance_info['Reservations']:
+        raise ValueError(f'EC2 instance {instance_id} not found')
+
+    instance = instance_info['Reservations'][0]['Instances'][0]
+    instance_vpc_id = instance['VpcId']
+
+    # Check VPC compatibility
+    if instance_vpc_id != cache_vpc_id:
+        raise ValueError(
+            f'EC2 instance VPC ({instance_vpc_id}) does not match cache cluster VPC ({cache_vpc_id})'
+        )
+
+    # Get EC2 instance security groups
+    instance_security_groups = [sg['GroupId'] for sg in instance['SecurityGroups']]
+    if not instance_security_groups:
+        raise ValueError(f'No security groups found for EC2 instance {instance_id}')
+
+    # For each cache security group, ensure it allows inbound access from EC2 security groups
+    for cache_sg in cache_security_groups:
+        cache_sg_id = cache_sg['SecurityGroupId']
+        cache_sg_info = ec2_client.describe_security_groups(GroupIds=[cache_sg_id])[
+            'SecurityGroups'
+        ][0]
+
+        # Check existing rules
+        existing_rules = cache_sg_info.get('IpPermissions', [])
+        needs_rule = True
+
+        for rule in existing_rules:
+            if (
+                rule.get('IpProtocol') == 'tcp'
+                and rule.get('FromPort') == cache_port
+                and rule.get('ToPort') == cache_port
+            ):
+                # Check if any EC2 security group is already allowed
+                for group_pair in rule.get('UserIdGroupPairs', []):
+                    if group_pair.get('GroupId') in instance_security_groups:
+                        needs_rule = False
+                        break
+            if not needs_rule:
+                break
+
+        # Add rule if needed
+        if needs_rule:
+            ec2_client.authorize_security_group_ingress(
+                GroupId=cache_sg_id,
+                IpPermissions=[
+                    {
+                        'IpProtocol': 'tcp',
+                        'FromPort': cache_port,
+                        'ToPort': cache_port,
+                        'UserIdGroupPairs': [
+                            {
+                                'GroupId': instance_security_groups[0],
+                                'Description': f'Allow access from jump host {instance_id}',
+                            }
+                        ],
+                    }
+                ],
+            )
+
+    return True, cache_vpc_id, cache_port
+
+
+@mcp.tool(name='connect-jump-host-cache-cluster')
+@handle_exceptions
+async def connect_jump_host_cc(cache_cluster_id: str, instance_id: str) -> Dict[str, Any]:
+    """Configures an existing EC2 instance as a jump host to access an ElastiCache cluster.
+
+    Args:
+        cache_cluster_id (str): ID of the ElastiCache cluster to connect to
+        instance_id (str): ID of the EC2 instance to use as jump host
+
+    Returns:
+        Dict[str, Any]: Dictionary containing connection details and configuration status
+
+    Raises:
+        ValueError: If VPC compatibility check fails or required resources not found
+    """
+    # Check if readonly mode is enabled
+    if Context.readonly_mode():
+        raise ValueError(
+            'You have configured this tool in readonly mode. To make this change you will have to update your configuration.'
+        )
+
+    try:
+        # Configure security groups using common function
+        configured, vpc_id, cache_port = await _configure_security_groups(
+            cache_cluster_id, instance_id
+        )
+
+        return {
+            'Status': 'Success',
+            'InstanceId': instance_id,
+            'CacheClusterId': cache_cluster_id,
+            'CachePort': cache_port,
+            'VpcId': vpc_id,
+            'SecurityGroupsConfigured': configured,
+            'Message': 'Jump host connection configured successfully',
+        }
+
+    except Exception as e:
+        raise ValueError(str(e))
+
+
+@mcp.tool(name='get-ssh-tunnel-command-cache-cluster')
+@handle_exceptions
+async def get_ssh_tunnel_command_cc(
+    cache_cluster_id: str, instance_id: str
+) -> Dict[str, Union[str, int]]:
+    """Generates an SSH tunnel command to connect to an ElastiCache cluster through an EC2 jump host.
+
+    Args:
+        cache_cluster_id (str): ID of the ElastiCache cluster to connect to
+        instance_id (str): ID of the EC2 instance to use as jump host
+
+    Returns:
+        Dict[str, Union[str, int]]: Dictionary containing the SSH tunnel command and related details
+
+    Raises:
+        ValueError: If required resources not found or information cannot be retrieved
+    """
+    # Get AWS clients
+    ec2_client = EC2ConnectionManager.get_connection()
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    try:
+        # Get EC2 instance details
+        instance_info = ec2_client.describe_instances(InstanceIds=[instance_id])
+        if not instance_info['Reservations']:
+            raise ValueError(f'EC2 instance {instance_id} not found')
+
+        instance = instance_info['Reservations'][0]['Instances'][0]
+
+        # Get instance key name and public DNS
+        key_name = instance.get('KeyName')
+        if not key_name:
+            raise ValueError(f'No key pair associated with EC2 instance {instance_id}')
+
+        public_dns = instance.get('PublicDnsName')
+        if not public_dns:
+            raise ValueError(f'No public DNS name found for EC2 instance {instance_id}')
+
+        # Get instance platform details to determine user
+        platform = instance.get('Platform', '')
+        user = 'ec2-user'  # Default for Amazon Linux
+        if platform.lower() == 'windows':
+            raise ValueError('Windows instances are not supported for SSH tunneling')
+        elif 'ubuntu' in instance.get('ImageId', '').lower():
+            user = 'ubuntu'
+
+        # Get cache cluster details
+        cache_cluster = elasticache_client.describe_cache_clusters(
+            CacheClusterId=cache_cluster_id, ShowCacheNodeInfo=True
+        )['CacheClusters'][0]
+
+        # Get cache endpoint and port
+        if not cache_cluster.get('CacheNodes'):
+            raise ValueError(f'No cache nodes found for cluster {cache_cluster_id}')
+
+        cache_endpoint = cache_cluster['CacheNodes'][0]['Endpoint']['Address']
+        cache_port = cache_cluster['CacheNodes'][0]['Endpoint']['Port']
+
+        # Generate SSH tunnel command
+        ssh_command = (
+            f'ssh -i "{key_name}.pem" -fN -l {user} '
+            f'-L {cache_port}:{cache_endpoint}:{cache_port} {public_dns} -v'
+        )
+
+        return {
+            'command': ssh_command,
+            'keyName': key_name,
+            'user': user,
+            'localPort': cache_port,
+            'cacheEndpoint': cache_endpoint,
+            'cachePort': cache_port,
+            'jumpHostDns': public_dns,
+        }
+
+    except Exception as e:
+        raise ValueError(str(e))
+
+
+@mcp.tool(name='create-jump-host-cache-cluster')
+@handle_exceptions
+async def create_jump_host_cc(
+    cache_cluster_id: str,
+    subnet_id: str,
+    security_group_id: str,
+    key_name: str,
+    instance_type: str = 't3.small',
+) -> Dict[str, Any]:
+    """Creates an EC2 jump host instance to access an ElastiCache cluster via SSH tunnel.
+
+    Args:
+        cache_cluster_id (str): ID of the ElastiCache cluster to connect to
+        subnet_id (str): ID of the subnet to launch the EC2 instance in (must be public)
+        security_group_id (str): ID of the security group to assign to the EC2 instance
+        key_name (str): Name of the EC2 key pair to use for SSH access
+        instance_type (str, optional): EC2 instance type. Defaults to "t3.small"
+
+    Returns:
+        Dict[str, Any]: Dictionary containing the created EC2 instance details
+
+    Raises:
+        ValueError: If subnet is not public or VPC compatibility check fails
+    """
+    # Check if readonly mode is enabled
+    if Context.readonly_mode():
+        raise ValueError(
+            'You have configured this tool in readonly mode. To make this change you will have to update your configuration.'
+        )
+
+    # Get AWS clients from connection managers
+    ec2_client = EC2ConnectionManager.get_connection()
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    try:
+        # Validate key_name
+        if not key_name:
+            raise ValueError(
+                'key_name is required. Use CreateKeyPair or ImportKeyPair EC2 APIs to create/import an SSH key pair.'
+            )
+
+        # Verify key pair exists
+        key_pairs = ec2_client.describe_key_pairs(KeyNames=[key_name])
+        if not key_pairs.get('KeyPairs'):
+            return {
+                'error': f"Key pair '{key_name}' not found. Use CreateKeyPair or ImportKeyPair EC2 APIs to create/import an SSH key pair."
+            }
+
+        # Get cache cluster details to find its VPC
+        cache_cluster = elasticache_client.describe_cache_clusters(
+            CacheClusterId=cache_cluster_id, ShowCacheNodeInfo=True
+        )['CacheClusters'][0]
+
+        cache_subnet_group = elasticache_client.describe_cache_subnet_groups(
+            CacheSubnetGroupName=cache_cluster['CacheSubnetGroupName']
+        )['CacheSubnetGroups'][0]
+        cache_vpc_id = cache_subnet_group['VpcId']
+
+        # Get subnet details and verify it's public
+        subnet_response = ec2_client.describe_subnets(SubnetIds=[subnet_id])
+        subnet = subnet_response['Subnets'][0]
+        subnet_vpc_id = subnet['VpcId']
+
+        # Check VPC compatibility
+        if subnet_vpc_id != cache_vpc_id:
+            raise ValueError(
+                f'Subnet VPC ({subnet_vpc_id}) does not match cache cluster VPC ({cache_vpc_id})'
+            )
+
+        # Check if subnet is public by looking for route to internet gateway
+        route_tables = ec2_client.describe_route_tables(
+            Filters=[{'Name': 'association.subnet-id', 'Values': [subnet_id]}]
+        )['RouteTables']
+
+        is_public = False
+        for rt in route_tables:
+            for route in rt.get('Routes', []):
+                if route.get('GatewayId', '').startswith('igw-'):
+                    is_public = True
+                    break
+            if is_public:
+                break
+
+        if not is_public:
+            raise ValueError(
+                f'Subnet {subnet_id} is not public (no route to internet gateway found). '
+                'The subnet must be public to allow SSH access to the jump host.'
+            )
+
+        # Use Amazon Linux 2023 AMI
+        images = ec2_client.describe_images(
+            Filters=[
+                {'Name': 'name', 'Values': ['al2023-ami-2023.*-x86_64']},
+                {'Name': 'owner-alias', 'Values': ['amazon']},
+            ]
+        )
+        ami_id = sorted(images['Images'], key=lambda x: x['CreationDate'], reverse=True)[0][
+            'ImageId'
+        ]
+
+        # Verify and update security group rules for SSH access
+        security_group = ec2_client.describe_security_groups(GroupIds=[security_group_id])[
+            'SecurityGroups'
+        ][0]
+
+        # Check if port 22 is already open
+        has_ssh_rule = False
+        for rule in security_group.get('IpPermissions', []):
+            if (
+                rule.get('IpProtocol') == 'tcp'
+                and rule.get('FromPort') == 22
+                and rule.get('ToPort') == 22
+                and any(
+                    ip_range.get('CidrIp') == '0.0.0.0/0' for ip_range in rule.get('IpRanges', [])
+                )
+            ):
+                has_ssh_rule = True
+                break
+
+        # Add SSH rule if it doesn't exist
+        if not has_ssh_rule:
+            ec2_client.authorize_security_group_ingress(
+                GroupId=security_group_id,
+                IpPermissions=[
+                    {
+                        'IpProtocol': 'tcp',
+                        'FromPort': 22,
+                        'ToPort': 22,
+                        'IpRanges': [
+                            {'CidrIp': '0.0.0.0/0', 'Description': 'SSH access from anywhere'}
+                        ],
+                    }
+                ],
+            )
+
+        # Launch EC2 instance
+        instance = ec2_client.run_instances(
+            ImageId=ami_id,
+            InstanceType=instance_type,
+            KeyName=key_name,
+            MaxCount=1,
+            MinCount=1,
+            NetworkInterfaces=[
+                {
+                    'SubnetId': subnet_id,
+                    'DeviceIndex': 0,
+                    'AssociatePublicIpAddress': True,
+                    'Groups': [security_group_id],
+                }
+            ],
+            TagSpecifications=[
+                {
+                    'ResourceType': 'instance',
+                    'Tags': [{'Key': 'Name', 'Value': f'ElastiCache-JumpHost-{cache_cluster_id}'}],
+                }
+            ],
+        )
+
+        # Wait for instance to be running and get its public IP
+        waiter = ec2_client.get_waiter('instance_running')
+        instance_id = instance['Instances'][0]['InstanceId']
+        waiter.wait(InstanceIds=[instance_id])
+
+        instance_info = ec2_client.describe_instances(InstanceIds=[instance_id])
+        public_ip = instance_info['Reservations'][0]['Instances'][0]['PublicIpAddress']
+
+        # Configure security groups using common function
+        configured, vpc_id, cache_port = await _configure_security_groups(
+            cache_cluster_id,
+            instance_id,
+            ec2_client=ec2_client,
+            elasticache_client=elasticache_client,
+        )
+
+        return {
+            'InstanceId': instance_id,
+            'PublicIpAddress': public_ip,
+            'InstanceType': instance_type,
+            'SubnetId': subnet_id,
+            'SecurityGroupId': security_group_id,
+            'CacheClusterId': cache_cluster_id,
+            'SecurityGroupsConfigured': configured,
+            'CachePort': cache_port,
+            'VpcId': vpc_id,
+        }
+
+    except ClientError as e:
+        if e.response['Error']['Code'] == 'InvalidKeyPair.NotFound':
+            return {
+                'error': f"Key pair '{key_name}' not found. Use CreateKeyPair or ImportKeyPair EC2 APIs to create/import an SSH key pair."
+            }
+        return {'error': str(e)}
+    except Exception as e:
+        return {'error': str(e)}

awslabs/elasticache_mcp_server/tools/cc/create.py

@@ -0,0 +1,212 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Create cache cluster tool for ElastiCache MCP server."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from ..rg.processors import process_log_delivery_configurations
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, Dict, List, Optional, Union
+
+
+class CreateCacheClusterRequest(BaseModel):
+    """Request model for creating an ElastiCache cache cluster."""
+
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+    cache_cluster_id: str = Field(..., description='The cache cluster identifier')
+    cache_node_type: Optional[str] = Field(
+        None, description='The compute and memory capacity of nodes'
+    )
+    engine: Optional[str] = Field(None, description='The name of the cache engine')
+    engine_version: Optional[str] = Field(
+        None, description='The version number of the cache engine'
+    )
+    num_cache_nodes: Optional[int] = Field(None, description='The number of cache nodes', gt=0)
+    preferred_availability_zone: Optional[str] = Field(
+        None, description='The EC2 Availability Zone for the cluster'
+    )
+    preferred_availability_zones: Optional[List[str]] = Field(
+        None, description='List of preferred Availability Zones'
+    )
+    cache_parameter_group_name: Optional[str] = Field(
+        None, description='The name of the parameter group to associate'
+    )
+    cache_subnet_group_name: Optional[str] = Field(
+        None, description='The name of the cache subnet group to use'
+    )
+    cache_security_group_names: Optional[List[str]] = Field(
+        None, description='List of cache security group names'
+    )
+    security_group_ids: Optional[List[str]] = Field(
+        None, description='List of Amazon VPC security group IDs'
+    )
+    tags: Optional[Union[str, List[Dict[str, str]], Dict[str, str]]] = Field(
+        None, description='Tags to apply'
+    )
+    snapshot_arns: Optional[List[str]] = Field(
+        None, description='List of ARNs of snapshots to restore from'
+    )
+    snapshot_name: Optional[str] = Field(
+        None, description='The name of a snapshot to restore from'
+    )
+    preferred_maintenance_window: Optional[str] = Field(
+        None, description='The weekly time range for maintenance'
+    )
+    port: Optional[int] = Field(
+        None, description='The port number on which the cache accepts connections'
+    )
+    notification_topic_arn: Optional[str] = Field(
+        None, description='The ARN of an SNS topic for notifications'
+    )
+    auto_minor_version_upgrade: Optional[bool] = Field(
+        None, description='Enable/disable automatic minor version upgrades'
+    )
+    snapshot_retention_limit: Optional[int] = Field(
+        None, description='The number of days to retain backups'
+    )
+    snapshot_window: Optional[str] = Field(None, description='The daily time range for backups')
+    auth_token: Optional[str] = Field(
+        None, description='Password used to access a password protected server'
+    )
+    outpost_mode: Optional[str] = Field(
+        None, description="Outpost mode ('single-outpost' or 'cross-outpost')"
+    )
+    preferred_outpost_arn: Optional[str] = Field(
+        None, description='The ARN of the preferred outpost'
+    )
+    preferred_outpost_arns: Optional[List[str]] = Field(
+        None, description='List of preferred outpost ARNs'
+    )
+    log_delivery_configurations: Optional[Union[str, List[Dict]]] = Field(
+        None, description='Log delivery configurations'
+    )
+
+
+@mcp.tool(name='create-cache-cluster')
+@handle_exceptions
+async def create_cache_cluster(request: CreateCacheClusterRequest) -> Dict:
+    """Create an Amazon ElastiCache cache cluster."""
+    # Check if readonly mode is enabled
+    if Context.readonly_mode():
+        raise ValueError(
+            'You have configured this tool in readonly mode. To make this change you will have to update your configuration.'
+        )
+
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    # Convert request model to dictionary, only including non-None values
+    create_request: Dict[str, Any] = {
+        'CacheClusterId': request.cache_cluster_id
+    }  # Required parameter
+
+    # Optional parameters - only include if they have a value
+    if request.cache_node_type is not None:
+        create_request['CacheNodeType'] = request.cache_node_type
+    if request.engine is not None:
+        create_request['Engine'] = request.engine
+    if request.engine_version is not None:
+        create_request['EngineVersion'] = request.engine_version
+    if request.num_cache_nodes is not None:
+        create_request['NumCacheNodes'] = request.num_cache_nodes
+    if request.preferred_availability_zone is not None:
+        create_request['PreferredAvailabilityZone'] = request.preferred_availability_zone
+    if request.preferred_availability_zones is not None:
+        create_request['PreferredAvailabilityZones'] = request.preferred_availability_zones
+    if request.cache_parameter_group_name is not None:
+        create_request['CacheParameterGroupName'] = request.cache_parameter_group_name
+    if request.cache_subnet_group_name is not None:
+        create_request['CacheSubnetGroupName'] = request.cache_subnet_group_name
+    if request.cache_security_group_names is not None:
+        create_request['CacheSecurityGroupNames'] = request.cache_security_group_names
+    if request.security_group_ids is not None:
+        create_request['SecurityGroupIds'] = request.security_group_ids
+    if request.tags:
+        if isinstance(request.tags, str):
+            # Parse shorthand syntax: Key=string,Value=string
+            tag_list = []
+            try:
+                pairs = [p.strip() for p in request.tags.split(',') if p.strip()]
+                for pair in pairs:
+                    if '=' not in pair:
+                        return {
+                            'error': 'Invalid tag format. Each tag must be in Key=Value format'
+                        }
+                    key, value = pair.split('=', 1)
+                    key = key.strip()
+                    value = value.strip() if value.strip() else None
+                    if not key:
+                        return {'error': 'Tag key cannot be empty'}
+                    tag_list.append({'Key': key, 'Value': value})
+                create_request['Tags'] = tag_list
+            except Exception as e:
+                return {
+                    'error': f'Invalid tag shorthand syntax. Expected format: Key=string,Value=string. Error: {str(e)}'
+                }
+        elif isinstance(request.tags, dict):
+            # Handle dictionary format
+            tag_list = []
+            for k, v in request.tags.items():
+                if not k:
+                    return {'error': 'Tag key cannot be empty'}
+                tag_list.append({'Key': k, 'Value': v})
+            create_request['Tags'] = tag_list
+        elif isinstance(request.tags, list):
+            # Handle list format
+            for tag in request.tags:
+                if not isinstance(tag, dict) or 'Key' not in tag:
+                    return {'error': 'Each tag must be a dictionary with a Key'}
+                if not tag['Key']:
+                    return {'error': 'Tag key cannot be empty'}
+            create_request['Tags'] = request.tags
+    if request.snapshot_arns is not None:
+        create_request['SnapshotArns'] = request.snapshot_arns
+    if request.snapshot_name is not None:
+        create_request['SnapshotName'] = request.snapshot_name
+    if request.preferred_maintenance_window is not None:
+        create_request['PreferredMaintenanceWindow'] = request.preferred_maintenance_window
+    if request.port is not None:
+        create_request['Port'] = request.port
+    if request.notification_topic_arn is not None:
+        create_request['NotificationTopicArn'] = request.notification_topic_arn
+    if request.auto_minor_version_upgrade is not None:
+        create_request['AutoMinorVersionUpgrade'] = request.auto_minor_version_upgrade
+    if request.snapshot_retention_limit is not None:
+        create_request['SnapshotRetentionLimit'] = request.snapshot_retention_limit
+    if request.snapshot_window is not None:
+        create_request['SnapshotWindow'] = request.snapshot_window
+    if request.auth_token is not None:
+        create_request['AuthToken'] = request.auth_token
+    if request.outpost_mode is not None:
+        create_request['OutpostMode'] = request.outpost_mode
+    if request.preferred_outpost_arn is not None:
+        create_request['PreferredOutpostArn'] = request.preferred_outpost_arn
+    if request.preferred_outpost_arns is not None:
+        create_request['PreferredOutpostArns'] = request.preferred_outpost_arns
+    if request.log_delivery_configurations:
+        try:
+            processed_configs = process_log_delivery_configurations(
+                request.log_delivery_configurations
+            )
+            create_request['LogDeliveryConfigurations'] = processed_configs
+        except ValueError as e:
+            return {'error': str(e)}
+
+    # Create the cache cluster
+    response = elasticache_client.create_cache_cluster(**create_request)
+    return response