localstack-core 4.10.1.dev42__py3-none-any.whl → 4.12.1.dev18__py3-none-any.whl

localstack/services/lambda_/provider.py

@@ -27,6 +27,7 @@ from localstack.aws.api.lambda_ import (
     Arn,
     Blob,
     BlobStream,
+    CapacityProviderConfig,
     CodeSigningConfigArn,
     CodeSigningConfigNotFoundException,
     CodeSigningPolicies,
@@ -39,8 +40,10 @@ from localstack.aws.api.lambda_ import (
     CreateFunctionRequest,
     CreateFunctionUrlConfigResponse,
     DeleteCodeSigningConfigResponse,
+    DeleteFunctionResponse,
     Description,
     DestinationConfig,
+    DurableExecutionName,
     EventSourceMappingConfiguration,
     FunctionCodeLocation,
     FunctionConfiguration,
@@ -48,6 +51,7 @@ from localstack.aws.api.lambda_ import (
     FunctionName,
     FunctionUrlAuthType,
     FunctionUrlQualifier,
+    FunctionVersionLatestPublished,
     GetAccountSettingsResponse,
     GetCodeSigningConfigResponse,
     GetFunctionCodeSigningConfigResponse,
@@ -65,6 +69,7 @@ from localstack.aws.api.lambda_ import (
     InvokeAsyncResponse,
     InvokeMode,
     LambdaApi,
+    LambdaManagedInstancesCapacityProviderConfig,
     LastUpdateStatus,
     LayerName,
     LayerPermissionAllowedAction,
@@ -99,6 +104,7 @@ from localstack.aws.api.lambda_ import (
     MaxProvisionedConcurrencyConfigListItems,
     NamespacedFunctionName,
     NamespacedStatementId,
+    NumericLatestPublishedOrAliasQualifier,
     OnFailure,
     OnSuccess,
     OrganizationId,
@@ -130,6 +136,7 @@ from localstack.aws.api.lambda_ import (
     TaggableResource,
     TagKeyList,
     Tags,
+    TenantId,
     TracingMode,
     UnqualifiedFunctionName,
     UpdateCodeSigningConfigResponse,
@@ -137,7 +144,7 @@ from localstack.aws.api.lambda_ import (
     UpdateFunctionCodeRequest,
     UpdateFunctionConfigurationRequest,
     UpdateFunctionUrlConfigResponse,
-    Version,
+    VersionWithLatestPublished,
 )
 from localstack.aws.api.lambda_ import FunctionVersion as FunctionVersionApi
 from localstack.aws.api.lambda_ import ServiceException as LambdaServiceException
@@ -151,6 +158,7 @@ from localstack.services.edge import ROUTER
 from localstack.services.lambda_ import api_utils
 from localstack.services.lambda_ import hooks as lambda_hooks
 from localstack.services.lambda_.analytics import (
+    FunctionInitializationType,
     FunctionOperation,
     FunctionStatus,
     function_counter,
@@ -209,6 +217,7 @@ from localstack.services.lambda_.invocation.lambda_service import (
     store_lambda_archive,
     store_s3_bucket_archive,
 )
+from localstack.services.lambda_.invocation.models import CapacityProvider as CapacityProviderModel
 from localstack.services.lambda_.invocation.models import LambdaStore
 from localstack.services.lambda_.invocation.runtime_executor import get_runtime_executor
 from localstack.services.lambda_.lambda_utils import HINT_LOG
@@ -231,6 +240,7 @@ from localstack.services.plugins import ServiceLifecycleHook
 from localstack.state import StateVisitor
 from localstack.utils.aws.arns import (
     ArnData,
+    capacity_provider_arn,
     extract_resource_from_arn,
     extract_service_from_arn,
     get_partition,
@@ -239,7 +249,7 @@ from localstack.utils.aws.arns import (
 )
 from localstack.utils.aws.client_types import ServicePrincipal
 from localstack.utils.bootstrap import is_api_enabled
-from localstack.utils.collections import PaginatedList
+from localstack.utils.collections import PaginatedList, merge_recursive
 from localstack.utils.event_matcher import validate_event_pattern
 from localstack.utils.strings import get_random_hex, short_uid, to_bytes, to_str
 from localstack.utils.sync import poll_condition
@@ -247,6 +257,7 @@ from localstack.utils.urls import localstack_host
 
 LOG = logging.getLogger(__name__)
 
+CAPACITY_PROVIDER_ARN_NAME = "arn:aws[a-zA-Z-]*:lambda:(eusc-)?[a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:\\d{12}:capacity-provider:[a-zA-Z0-9-_]+"
 LAMBDA_DEFAULT_TIMEOUT = 3
 LAMBDA_DEFAULT_MEMORY_SIZE = 128
 
@@ -296,19 +307,26 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             for region_name, state in account_bundle.items():
                 for fn in state.functions.values():
                     for fn_version in fn.versions.values():
-                        # restore the "Pending" state for every function version and start it
                         try:
-                            new_state = VersionState(
-                                state=State.Pending,
-                                code=StateReasonCode.Creating,
-                                reason="The function is being created.",
-                            )
-                            new_config = dataclasses.replace(fn_version.config, state=new_state)
-                            new_version = dataclasses.replace(fn_version, config=new_config)
-                            fn.versions[fn_version.id.qualifier] = new_version
-                            self.lambda_service.create_function_version(fn_version).result(
-                                timeout=5
+                            # $LATEST is not invokable for Lambda functions with a capacity provider
+                            # and has a different State (i.e., ActiveNonInvokable)
+                            is_capacity_provider_latest = (
+                                fn_version.config.CapacityProviderConfig
+                                and fn_version.id.qualifier == "$LATEST"
                             )
+                            if not is_capacity_provider_latest:
+                                # Restore the "Pending" state for the function version and start it
+                                new_state = VersionState(
+                                    state=State.Pending,
+                                    code=StateReasonCode.Creating,
+                                    reason="The function is being created.",
+                                )
+                                new_config = dataclasses.replace(fn_version.config, state=new_state)
+                                new_version = dataclasses.replace(fn_version, config=new_config)
+                                fn.versions[fn_version.id.qualifier] = new_version
+                                self.lambda_service.create_function_version(fn_version).result(
+                                    timeout=5
+                                )
                         except Exception:
                             LOG.warning(
                                 "Failed to restore function version %s",
@@ -419,6 +437,23 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             )
         return esm
 
+    @staticmethod
+    def _get_capacity_provider(
+        capacity_provider_name: str,
+        account_id: str,
+        region: str,
+        error_msg_template: str = "Capacity provider not found: {}",
+    ) -> CapacityProviderModel:
+        state = lambda_stores[account_id][region]
+        cp = state.capacity_providers.get(capacity_provider_name)
+        if not cp:
+            arn = capacity_provider_arn(capacity_provider_name, account_id, region)
+            raise ResourceNotFoundException(
+                error_msg_template.format(arn),
+                Type="User",
+            )
+        return cp
+
     @staticmethod
     def _validate_qualifier_expression(qualifier: str) -> None:
         if error_messages := api_utils.validate_qualifier(qualifier):
@@ -489,7 +524,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         subnet_id = subnet_ids[0]
         if not bool(SUBNET_ID_REGEX.match(subnet_id)):
             raise ValidationException(
-                f"1 validation error detected: Value '[{subnet_id}]' at 'vpcConfig.subnetIds' failed to satisfy constraint: Member must satisfy constraint: [Member must have length less than or equal to 1024, Member must have length greater than or equal to 0, Member must satisfy regular expression pattern: ^subnet-[0-9a-z]*$]"
+                f"1 validation error detected: Value '[{subnet_id}]' at 'vpcConfig.subnetIds' failed to satisfy constraint: Member must satisfy constraint: [Member must have length less than or equal to 1024, Member must have length greater than or equal to 0, Member must satisfy regular expression pattern: subnet-[0-9a-z]*]"
             )
 
         return VpcConfig(
@@ -506,6 +541,8 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         description: str | None = None,
         revision_id: str | None = None,
         code_sha256: str | None = None,
+        publish_to: FunctionVersionLatestPublished | None = None,
+        is_active: bool = False,
     ) -> tuple[FunctionVersion, bool]:
         """
         Release a new version to the model if all restrictions are met.
@@ -568,38 +605,57 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 ):
                     return prev_version, False
             # TODO check if there was a change since last version
-            next_version = str(function.next_version)
-            function.next_version += 1
+            if publish_to == FunctionVersionLatestPublished.LATEST_PUBLISHED:
+                qualifier = "$LATEST.PUBLISHED"
+            else:
+                qualifier = str(function.next_version)
+                function.next_version += 1
             new_id = VersionIdentifier(
                 function_name=function_name,
-                qualifier=next_version,
+                qualifier=qualifier,
                 region=region,
                 account=account_id,
             )
-            apply_on = current_latest_version.config.snap_start["ApplyOn"]
-            optimization_status = SnapStartOptimizationStatus.Off
-            if apply_on == SnapStartApplyOn.PublishedVersions:
-                optimization_status = SnapStartOptimizationStatus.On
-            snap_start = SnapStartResponse(
-                ApplyOn=apply_on,
-                OptimizationStatus=optimization_status,
+
+            if current_latest_version.config.CapacityProviderConfig:
+                # for lambda managed functions, snap start is not supported
+                snap_start = None
+            else:
+                apply_on = current_latest_version.config.snap_start["ApplyOn"]
+                optimization_status = SnapStartOptimizationStatus.Off
+                if apply_on == SnapStartApplyOn.PublishedVersions:
+                    optimization_status = SnapStartOptimizationStatus.On
+                snap_start = SnapStartResponse(
+                    ApplyOn=apply_on,
+                    OptimizationStatus=optimization_status,
+                )
+
+            last_update = None
+            new_state = VersionState(
+                state=State.Pending,
+                code=StateReasonCode.Creating,
+                reason="The function is being created.",
             )
+            if publish_to == FunctionVersionLatestPublished.LATEST_PUBLISHED:
+                last_update = UpdateStatus(
+                    status=LastUpdateStatus.InProgress,
+                    code="Updating",
+                    reason="The function is being updated.",
+                )
+                if is_active:
+                    new_state = VersionState(state=State.Active)
             new_version = dataclasses.replace(
                 current_latest_version,
                 config=dataclasses.replace(
                     current_latest_version.config,
-                    last_update=None,  # versions never have a last update status
-                    state=VersionState(
-                        state=State.Pending,
-                        code=StateReasonCode.Creating,
-                        reason="The function is being created.",
-                    ),
+                    last_update=last_update,
+                    state=new_state,
                     snap_start=snap_start,
                     **changes,
                 ),
                 id=new_id,
             )
-            function.versions[next_version] = new_version
+            function.versions[qualifier] = new_version
         return new_version, True
 
     def _publish_version_from_existing_version(
@@ -610,6 +666,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         description: str | None = None,
         revision_id: str | None = None,
         code_sha256: str | None = None,
+        publish_to: FunctionVersionLatestPublished | None = None,
     ) -> FunctionVersion:
         """
         Publish version from an existing, already initialized LATEST
@@ -622,6 +679,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         :param code_sha256: code sha (check if current code matches)
         :return: new version
         """
+        is_active = True if publish_to == FunctionVersionLatestPublished.LATEST_PUBLISHED else False
         new_version, changed = self._create_version_model(
             function_name=function_name,
             region=region,
@@ -629,18 +687,34 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             description=description,
             revision_id=revision_id,
             code_sha256=code_sha256,
+            publish_to=publish_to,
+            is_active=is_active,
         )
         if not changed:
             return new_version
-        self.lambda_service.publish_version(new_version)
+
+        if new_version.config.CapacityProviderConfig:
+            self.lambda_service.publish_version_async(new_version)
+        else:
+            self.lambda_service.publish_version(new_version)
         state = lambda_stores[account_id][region]
         function = state.functions.get(function_name)
+
+        # Update revision id for $LATEST version
         # TODO: re-evaluate data model to prevent this dirty hack just for bumping the revision id
         latest_version = function.versions["$LATEST"]
         function.versions["$LATEST"] = dataclasses.replace(
             latest_version, config=dataclasses.replace(latest_version.config)
         )
-        return function.versions.get(new_version.id.qualifier)
+        if new_version.config.CapacityProviderConfig:
+            # publish_version happens async for functions with a capacity provider.
+            # Therefore, we return the new_version with State=Pending or LastUpdateStatus=InProgress ($LATEST.PUBLISHED)
+            return new_version
+        else:
+            # Regular functions yield an Active state modified during `publish_version` (sync).
+            # Therefore, we need to get the updated version from the store.
+            updated_version = function.versions.get(new_version.id.qualifier)
+            return updated_version
 
     def _publish_version_with_changes(
         self,
@@ -650,6 +724,8 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         description: str | None = None,
         revision_id: str | None = None,
         code_sha256: str | None = None,
+        publish_to: FunctionVersionLatestPublished | None = None,
+        is_active: bool = False,
     ) -> FunctionVersion:
         """
         Publish version together with a new latest version (publish on create / update)
@@ -669,6 +745,8 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             description=description,
             revision_id=revision_id,
             code_sha256=code_sha256,
+            publish_to=publish_to,
+            is_active=is_active,
         )
         if not changed:
             return new_version
@@ -720,7 +798,8 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             if layer_version_str is None:
                 raise ValidationException(
                     f"1 validation error detected: Value '[{layer_version_arn}]'"
-                    + r" at 'layers' failed to satisfy constraint: Member must satisfy constraint: [Member must have length less than or equal to 140, Member must have length greater than or equal to 1, Member must satisfy regular expression pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\d{1}:\d{12}:layer:[a-zA-Z0-9-_]+:[0-9]+)|(arn:[a-zA-Z0-9-]+:lambda:::awslayer:[a-zA-Z0-9-_]+), Member must not be null]",
+                    + " at 'layers' failed to satisfy constraint: Member must satisfy constraint: [Member must have length less than or equal to 2048, Member must have length greater than or equal to 1, Member must satisfy regular expression pattern: "
+                    + "(arn:(aws[a-zA-Z-]*)?:lambda:(eusc-)?[a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:\\d{12}:layer:[a-zA-Z0-9-_]+:[0-9]+)|(arn:[a-zA-Z0-9-]+:lambda:::awslayer:[a-zA-Z0-9-_]+), Member must not be null]",
                 )
 
             state = lambda_stores[layer_account_id][layer_region]
@@ -783,6 +862,30 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 )
             visited_layers[layer_arn] = layer_version_arn
 
+    def _validate_capacity_provider_config(
+        self, capacity_provider_config: CapacityProviderConfig, context: RequestContext
+    ):
+        if not capacity_provider_config.get("LambdaManagedInstancesCapacityProviderConfig"):
+            raise ValidationException(
+                "1 validation error detected: Value null at 'capacityProviderConfig.lambdaManagedInstancesCapacityProviderConfig' failed to satisfy constraint: Member must not be null"
+            )
+
+        capacity_provider_arn = capacity_provider_config.get(
+            "LambdaManagedInstancesCapacityProviderConfig", {}
+        ).get("CapacityProviderArn")
+        if not capacity_provider_arn:
+            raise ValidationException(
+                "1 validation error detected: Value null at 'capacityProviderConfig.lambdaManagedInstancesCapacityProviderConfig.capacityProviderArn' failed to satisfy constraint: Member must not be null"
+            )
+
+        if not re.match(CAPACITY_PROVIDER_ARN_NAME, capacity_provider_arn):
+            raise ValidationException(
+                f"1 validation error detected: Value '{capacity_provider_arn}' at 'capacityProviderConfig.lambdaManagedInstancesCapacityProviderConfig.capacityProviderArn' failed to satisfy constraint: Member must satisfy regular expression pattern: {CAPACITY_PROVIDER_ARN_NAME}"
+            )
+
+        capacity_provider_name = capacity_provider_arn.split(":")[-1]
+        self.get_capacity_provider(context, capacity_provider_name)
+
     @staticmethod
     def map_layers(new_layers: list[str]) -> list[LayerVersion]:
         layers = []
@@ -941,11 +1044,13 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                         account_id=context_account_id,
                     )
                 else:
-                    raise LambdaServiceException("Gotta have s3 bucket or zip file")
+                    raise LambdaServiceException("A ZIP file or S3 bucket is required")
             elif package_type == PackageType.Image:
                 image = request_code.get("ImageUri")
                 if not image:
-                    raise LambdaServiceException("Gotta have an image when package type is image")
+                    raise LambdaServiceException(
+                        "An image is required when the package type is set to 'image'"
+                    )
                 image = create_image_code(image_uri=image)
 
                 image_config_req = request.get("ImageConfig", {})
@@ -956,6 +1061,26 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 )
                 # Runtime management controls are not available when providing a custom image
                 runtime_version_config = None
+
+            capacity_provider_config = None
+            memory_size = request.get("MemorySize", LAMBDA_DEFAULT_MEMORY_SIZE)
+            if "CapacityProviderConfig" in request:
+                capacity_provider_config = request["CapacityProviderConfig"]
+                self._validate_capacity_provider_config(capacity_provider_config, context)
+
+                default_config = CapacityProviderConfig(
+                    LambdaManagedInstancesCapacityProviderConfig=LambdaManagedInstancesCapacityProviderConfig(
+                        ExecutionEnvironmentMemoryGiBPerVCpu=2.0,
+                        PerExecutionEnvironmentMaxConcurrency=16,
+                    )
+                )
+                capacity_provider_config = merge_recursive(default_config, capacity_provider_config)
+                memory_size = 2048
+                if request.get("LoggingConfig", {}).get("LogFormat") == LogFormat.Text:
+                    raise InvalidParameterValueException(
+                        'LogLevel is not supported when LogFormat is set to "Text". Remove LogLevel from your request or change the LogFormat to "JSON" and try again.',
+                        Type="User",
+                    )
             if "LoggingConfig" in request:
                 logging_config = request["LoggingConfig"]
                 LOG.warning(
@@ -979,11 +1104,25 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                         | logging_config
                     )
 
+            elif capacity_provider_config:
+                logging_config = LoggingConfig(
+                    LogFormat=LogFormat.JSON,
+                    LogGroup=f"/aws/lambda/{function_name}",
+                    ApplicationLogLevel="INFO",
+                    SystemLogLevel="INFO",
+                )
             else:
                 logging_config = LoggingConfig(
                     LogFormat=LogFormat.Text, LogGroup=f"/aws/lambda/{function_name}"
                 )
-
+            snap_start = (
+                None
+                if capacity_provider_config
+                else SnapStartResponse(
+                    ApplyOn=request.get("SnapStart", {}).get("ApplyOn", SnapStartApplyOn.None_),
+                    OptimizationStatus=SnapStartOptimizationStatus.Off,
+                )
+            )
             version = FunctionVersion(
                 id=arn,
                 config=VersionFunctionConfiguration(
@@ -992,7 +1131,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                     role=request["Role"],
                     timeout=request.get("Timeout", LAMBDA_DEFAULT_TIMEOUT),
                     runtime=request.get("Runtime"),
-                    memory_size=request.get("MemorySize", LAMBDA_DEFAULT_MEMORY_SIZE),
+                    memory_size=memory_size,
                     handler=request.get("Handler"),
                     package_type=package_type,
                     environment=env_vars,
@@ -1008,10 +1147,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                     ephemeral_storage=LambdaEphemeralStorage(
                         size=request.get("EphemeralStorage", {}).get("Size", 512)
                     ),
-                    snap_start=SnapStartResponse(
-                        ApplyOn=request.get("SnapStart", {}).get("ApplyOn", SnapStartApplyOn.None_),
-                        OptimizationStatus=SnapStartOptimizationStatus.Off,
-                    ),
+                    snap_start=snap_start,
                     runtime_version_config=runtime_version_config,
                     dead_letter_arn=request.get("DeadLetterConfig", {}).get("TargetArn"),
                     vpc_config=self._build_vpc_config(
@@ -1023,18 +1159,40 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                         reason="The function is being created.",
                     ),
                     logging_config=logging_config,
+                    # TODO: might need something like **optional_kwargs if None
+                    #   -> Test with regular GetFunction (i.e., without a capacity provider)
+                    CapacityProviderConfig=capacity_provider_config,
                 ),
             )
-            fn.versions["$LATEST"] = version
+            version_post_response = None
+            if capacity_provider_config:
+                version_post_response = dataclasses.replace(
+                    version,
+                    config=dataclasses.replace(
+                        version.config,
+                        last_update=UpdateStatus(status=LastUpdateStatus.Successful),
+                        state=VersionState(state=State.ActiveNonInvocable),
+                    ),
+                )
+            fn.versions["$LATEST"] = version_post_response or version
             state.functions[function_name] = fn
+        initialization_type = (
+            FunctionInitializationType.lambda_managed_instances
+            if capacity_provider_config
+            else FunctionInitializationType.on_demand
+        )
         function_counter.labels(
             operation=FunctionOperation.create,
             runtime=runtime or "n/a",
             status=FunctionStatus.success,
             invocation_type="n/a",
             package_type=package_type,
+            initialization_type=initialization_type,
         )
-        self.lambda_service.create_function_version(version)
+        # TODO: consider potential other side effects of not having a function version for $LATEST
+        # Provisioning happens upon publishing for functions using a capacity provider
+        if not capacity_provider_config:
+            self.lambda_service.create_function_version(version)
 
         if tags := request.get("Tags"):
             # This will check whether the function exists.
@@ -1042,7 +1200,10 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
 
         if request.get("Publish"):
             version = self._publish_version_with_changes(
-                function_name=function_name, region=context_region, account_id=context_account_id
+                function_name=function_name,
+                region=context_region,
+                account_id=context_account_id,
+                publish_to=request.get("PublishTo"),
             )
 
         if config.LAMBDA_SYNCHRONOUS_CREATE:
@@ -1051,7 +1212,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 lambda: get_function_version(
                     function_name, version.id.qualifier, version.id.account, version.id.region
                 ).config.state.state
-                in [State.Active, State.Failed],
+                in [State.Active, State.ActiveNonInvocable, State.Failed],
                 timeout=10,
             ):
                 LOG.warning(
@@ -1242,6 +1403,19 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             if new_mode:
                 replace_kwargs["tracing_config_mode"] = new_mode
 
+        if "CapacityProviderConfig" in request:
+            if latest_version.config.CapacityProviderConfig and not request[
+                "CapacityProviderConfig"
+            ].get("LambdaManagedInstancesCapacityProviderConfig"):
+                raise ValidationException(
+                    "1 validation error detected: Value null at 'capacityProviderConfig.lambdaManagedInstancesCapacityProviderConfig' failed to satisfy constraint: Member must not be null"
+                )
+            if not latest_version.config.CapacityProviderConfig:
+                raise InvalidParameterValueException(
+                    "CapacityProviderConfig isn't supported for Lambda Default functions.",
+                    Type="User",
+                )
+
         new_latest_version = dataclasses.replace(
             latest_version,
             config=dataclasses.replace(
@@ -1327,7 +1501,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             code = None
             image = create_image_code(image_uri=image)
         else:
-            raise LambdaServiceException("Gotta have s3 bucket or zip file or image")
+            raise LambdaServiceException("A ZIP file, S3 bucket, or image is required")
 
         old_function_version = function.versions.get("$LATEST")
         replace_kwargs = {"code": code} if code else {"image": image}
@@ -1365,7 +1539,12 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self.lambda_service.update_version(new_version=function_version)
         if request.get("Publish"):
             function_version = self._publish_version_with_changes(
-                function_name=function_name, region=region, account_id=account_id
+                function_name=function_name,
+                region=region,
+                account_id=account_id,
+                # TODO: validations for PublishTo without Publish=True
+                publish_to=request.get("PublishTo"),
+                is_active=True,
             )
         return api_utils.map_config_out(
             function_version, return_qualified_arn=bool(request.get("Publish"))
@@ -1380,10 +1559,10 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
     def delete_function(
         self,
         context: RequestContext,
-        function_name: FunctionName,
-        qualifier: Qualifier = None,
+        function_name: NamespacedFunctionName,
+        qualifier: NumericLatestPublishedOrAliasQualifier | None = None,
         **kwargs,
-    ) -> None:
+    ) -> DeleteFunctionResponse:
         account_id, region = api_utils.get_account_and_region(function_name, context)
         function_name, qualifier = api_utils.get_name_and_qualifier(
             function_name, qualifier, context
@@ -1409,10 +1588,13 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             raise e
         function = store.functions.get(function_name)
 
+        function_has_capacity_provider = False
         if qualifier:
             # delete a version of the function
             version = function.versions.pop(qualifier, None)
             if version:
+                if version.config.CapacityProviderConfig:
+                    function_has_capacity_provider = True
                 self.lambda_service.stop_version(version.id.qualified_arn())
                 destroy_code_if_not_used(code=version.config.code, function=function)
         else:
@@ -1421,11 +1603,20 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             #  the old version gets cleaned up in the internal lambda service.
             function = store.functions.pop(function_name)
             for version in function.versions.values():
-                self.lambda_service.stop_version(qualified_arn=version.id.qualified_arn())
+                # Functions with a capacity provider do NOT have a version manager for $LATEST because only
+                # published versions are invokable.
+                if version.config.CapacityProviderConfig:
+                    function_has_capacity_provider = True
+                    if version.id.qualifier == "$LATEST":
+                        pass
+                else:
+                    self.lambda_service.stop_version(qualified_arn=version.id.qualified_arn())
                 # we can safely destroy the code here
                 if version.config.code:
                     version.config.code.destroy()
 
+        return DeleteFunctionResponse(StatusCode=202 if function_has_capacity_provider else 204)
+
     def list_functions(
         self,
         context: RequestContext,
@@ -1469,7 +1660,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: NamespacedFunctionName,
-        qualifier: Qualifier = None,
+        qualifier: NumericLatestPublishedOrAliasQualifier | None = None,
         **kwargs,
     ) -> GetFunctionResponse:
         account_id, region = api_utils.get_account_and_region(function_name, context)
@@ -1540,7 +1731,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: NamespacedFunctionName,
-        qualifier: Qualifier = None,
+        qualifier: NumericLatestPublishedOrAliasQualifier | None = None,
         **kwargs,
     ) -> FunctionConfiguration:
         account_id, region = api_utils.get_account_and_region(function_name, context)
@@ -1560,11 +1751,13 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: NamespacedFunctionName,
-        invocation_type: InvocationType = None,
-        log_type: LogType = None,
-        client_context: String = None,
-        payload: IO[Blob] = None,
-        qualifier: Qualifier = None,
+        invocation_type: InvocationType | None = None,
+        log_type: LogType | None = None,
+        client_context: String | None = None,
+        durable_execution_name: DurableExecutionName | None = None,
+        payload: IO[Blob] | None = None,
+        qualifier: NumericLatestPublishedOrAliasQualifier | None = None,
+        tenant_id: TenantId | None = None,
         **kwargs,
     ) -> InvocationResponse:
         account_id, region = api_utils.get_account_and_region(function_name, context)
@@ -1634,9 +1827,10 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: FunctionName,
-        code_sha256: String = None,
-        description: Description = None,
-        revision_id: String = None,
+        code_sha256: String | None = None,
+        description: Description | None = None,
+        revision_id: String | None = None,
+        publish_to: FunctionVersionLatestPublished | None = None,
         **kwargs,
     ) -> FunctionConfiguration:
         account_id, region = api_utils.get_account_and_region(function_name, context)
@@ -1648,6 +1842,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             region=region,
             revision_id=revision_id,
             code_sha256=code_sha256,
+            publish_to=publish_to,
         )
         return api_utils.map_config_out(new_version, return_qualified_arn=True)
 
@@ -1706,7 +1901,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 )
             if not api_utils.qualifier_is_version(key):
                 raise ValidationException(
-                    f"1 validation error detected: Value '{{{key}={value}}}' at 'routingConfig.additionalVersionWeights' failed to satisfy constraint: Map keys must satisfy constraint: [Member must have length less than or equal to 1024, Member must have length greater than or equal to 1, Member must satisfy regular expression pattern: [0-9]+, Member must not be null]"
+                    f"1 validation error detected: Value '{{{key}={value}}}' at 'routingConfig.additionalVersionWeights' failed to satisfy constraint: Map keys must satisfy constraint: [Member must have length less than or equal to 1024, Member must have length greater than or equal to 1, Member must satisfy regular expression pattern: [0-9]+]"
                 )
 
             # checking if the version in the config exists
@@ -1723,7 +1918,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         context: RequestContext,
         function_name: FunctionName,
         name: Alias,
-        function_version: Version,
+        function_version: VersionWithLatestPublished,
         description: Description = None,
         routing_config: AliasRoutingConfiguration = None,
         **kwargs,
@@ -1774,7 +1969,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: FunctionName,
-        function_version: Version = None,
+        function_version: VersionWithLatestPublished = None,
         marker: String = None,
         max_items: MaxListItems = None,
         **kwargs,
@@ -1842,7 +2037,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         context: RequestContext,
         function_name: FunctionName,
         name: Alias,
-        function_version: Version = None,
+        function_version: VersionWithLatestPublished = None,
         description: Description = None,
         routing_config: AliasRoutingConfiguration = None,
         revision_id: String = None,
@@ -2069,6 +2264,9 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                     raise Exception("unknown version")  # TODO: cover via test
             elif qualifier == "$LATEST":
                 pass
+            elif qualifier == "$LATEST.PUBLISHED":
+                if fn.versions.get(qualifier):
+                    pass
             else:
                 raise Exception("invalid functionname")  # TODO: cover via test
             fn_arn = api_utils.qualified_lambda_arn(function_name, qualifier, account, region)
@@ -2591,7 +2789,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             if revision_id != fn_revision_id:
                 raise PreconditionFailedException(
                     "The Revision Id provided does not match the latest Revision Id. "
-                    "Call the GetFunction/GetAlias API to retrieve the latest Revision Id",
+                    "Call the GetPolicy API to retrieve the latest Revision Id",
                     Type="User",
                 )
 
@@ -2649,10 +2847,10 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
     def remove_permission(
         self,
         context: RequestContext,
-        function_name: FunctionName,
+        function_name: NamespacedFunctionName,
         statement_id: NamespacedStatementId,
-        qualifier: Qualifier = None,
-        revision_id: String = None,
+        qualifier: NumericLatestPublishedOrAliasQualifier | None = None,
+        revision_id: String | None = None,
         **kwargs,
     ) -> None:
         account_id, region = api_utils.get_account_and_region(function_name, context)
@@ -2716,7 +2914,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: NamespacedFunctionName,
-        qualifier: Qualifier = None,
+        qualifier: NumericLatestPublishedOrAliasQualifier | None = None,
         **kwargs,
     ) -> GetPolicyResponse:
         account_id, region = api_utils.get_account_and_region(function_name, context)
@@ -2758,9 +2956,9 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         allowed_publishers: AllowedPublishers,
-        description: Description = None,
-        code_signing_policies: CodeSigningPolicies = None,
-        tags: Tags = None,
+        description: Description | None = None,
+        code_signing_policies: CodeSigningPolicies | None = None,
+        tags: Tags | None = None,
         **kwargs,
     ) -> CreateCodeSigningConfigResponse:
         account = context.account_id
@@ -2785,7 +2983,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         code_signing_config_arn: CodeSigningConfigArn,
-        function_name: FunctionName,
+        function_name: NamespacedFunctionName,
         **kwargs,
     ) -> PutFunctionCodeSigningConfigResponse:
         account_id, region = api_utils.get_account_and_region(function_name, context)
@@ -2852,7 +3050,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         return GetCodeSigningConfigResponse(CodeSigningConfig=api_utils.map_csc(csc))
 
     def get_function_code_signing_config(
-        self, context: RequestContext, function_name: FunctionName, **kwargs
+        self, context: RequestContext, function_name: NamespacedFunctionName, **kwargs
     ) -> GetFunctionCodeSigningConfigResponse:
         account_id, region = api_utils.get_account_and_region(function_name, context)
         state = lambda_stores[account_id][region]
@@ -2870,7 +3068,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         return GetFunctionCodeSigningConfigResponse()
 
     def delete_function_code_signing_config(
-        self, context: RequestContext, function_name: FunctionName, **kwargs
+        self, context: RequestContext, function_name: NamespacedFunctionName, **kwargs
     ) -> None:
         account_id, region = api_utils.get_account_and_region(function_name, context)
         state = lambda_stores[account_id][region]
@@ -3280,7 +3478,8 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 raise ValidationException(
                     "1 validation error detected: Value '"
                     + destination_arn
-                    + r"' at 'destinationConfig.onFailure.destination' failed to satisfy constraint: Member must satisfy regular expression pattern: ^$|arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\d{1})?:(\d{12})?:(.*)"
+                    + "' at 'destinationConfig.onFailure.destination' failed to satisfy constraint: Member must satisfy regular expression pattern: "
+                    + "$|kafka://([^.]([a-zA-Z0-9\\-_.]{0,248}))|arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\\-])+:((eusc-)?[a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1})?:(\\d{12})?:(.*)"
                 )
 
             match destination_arn.split(":")[2]:
@@ -3330,7 +3529,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: FunctionName,
-        qualifier: Qualifier = None,
+        qualifier: NumericLatestPublishedOrAliasQualifier = None,
         maximum_retry_attempts: MaximumRetryAttempts = None,
         maximum_event_age_in_seconds: MaximumEventAgeInSeconds = None,
         destination_config: DestinationConfig = None,
@@ -3412,7 +3611,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: FunctionName,
-        qualifier: Qualifier = None,
+        qualifier: NumericLatestPublishedOrAliasQualifier | None = None,
         **kwargs,
     ) -> FunctionEventInvokeConfig:
         account_id, region = api_utils.get_account_and_region(function_name, context)
@@ -3489,7 +3688,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: FunctionName,
-        qualifier: Qualifier = None,
+        qualifier: NumericLatestPublishedOrAliasQualifier | None = None,
         **kwargs,
     ) -> None:
         account_id, region = api_utils.get_account_and_region(function_name, context)
@@ -3517,7 +3716,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         function_name: FunctionName,
-        qualifier: Qualifier = None,
+        qualifier: NumericLatestPublishedOrAliasQualifier = None,
         maximum_retry_attempts: MaximumRetryAttempts = None,
         maximum_event_age_in_seconds: MaximumEventAgeInSeconds = None,
         destination_config: DestinationConfig = None,
@@ -3608,10 +3807,10 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         context: RequestContext,
         layer_name: LayerName,
         content: LayerVersionContentInput,
-        description: Description = None,
-        compatible_runtimes: CompatibleRuntimes = None,
-        license_info: LicenseInfo = None,
-        compatible_architectures: CompatibleArchitectures = None,
+        description: Description | None = None,
+        compatible_runtimes: CompatibleRuntimes | None = None,
+        license_info: LicenseInfo | None = None,
+        compatible_architectures: CompatibleArchitectures | None = None,
         **kwargs,
     ) -> PublishLayerVersionResponse:
         """
@@ -3749,10 +3948,10 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
     def list_layers(
         self,
         context: RequestContext,
-        compatible_runtime: Runtime = None,
-        marker: String = None,
-        max_items: MaxLayerListItems = None,
-        compatible_architecture: Architecture = None,
+        compatible_runtime: Runtime | None = None,
+        marker: String | None = None,
+        max_items: MaxLayerListItems | None = None,
+        compatible_architecture: Architecture | None = None,
         **kwargs,
     ) -> ListLayersResponse:
         validation_errors = []
@@ -3804,10 +4003,10 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         layer_name: LayerName,
-        compatible_runtime: Runtime = None,
-        marker: String = None,
-        max_items: MaxLayerListItems = None,
-        compatible_architecture: Architecture = None,
+        compatible_runtime: Runtime | None = None,
+        marker: String | None = None,
+        max_items: MaxLayerListItems | None = None,
+        compatible_architecture: Architecture | None = None,
         **kwargs,
     ) -> ListLayerVersionsResponse:
         validation_errors = api_utils.validate_layer_runtimes_and_architectures(
@@ -4155,7 +4354,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
 
     def fetch_lambda_store_for_tagging(self, resource: TaggableResource) -> LambdaStore:
         """
-        Takes a resource ARN for a TaggableResource (Lambda Function, Event Source Mapping, or Code Signing Config) and returns a corresponding
+        Takes a resource ARN for a TaggableResource (Lambda Function, Event Source Mapping, Code Signing Config, or Capacity Provider) and returns a corresponding
         LambdaStore for its region and account.
 
         In addition, this function validates that the ARN is a valid TaggableResource type, and that the TaggableResource exists.
@@ -4190,9 +4389,8 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             _raise_validation_exception()
 
         resource_type, resource_identifier, *qualifier = parts
-        if resource_type not in {"event-source-mapping", "code-signing-config", "function"}:
-            _raise_validation_exception()
 
+        # Qualifier validation raises before checking for NotFound
         if qualifier:
             if resource_type == "function":
                 raise InvalidParameterValueException(
@@ -4201,15 +4399,18 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 )
             _raise_validation_exception()
 
-        match resource_type:
-            case "event-source-mapping":
-                self._get_esm(resource_identifier, account_id, region)
-            case "code-signing-config":
-                raise NotImplementedError("Resource tagging on CSC not yet implemented.")
-            case "function":
-                self._get_function(
-                    function_name=resource_identifier, account_id=account_id, region=region
-                )
+        if resource_type == "event-source-mapping":
+            self._get_esm(resource_identifier, account_id, region)
+        elif resource_type == "code-signing-config":
+            raise NotImplementedError("Resource tagging on CSC not yet implemented.")
+        elif resource_type == "function":
+            self._get_function(
+                function_name=resource_identifier, account_id=account_id, region=region
+            )
+        elif resource_type == "capacity-provider":
+            self._get_capacity_provider(resource_identifier, account_id, region)
+        else:
+            _raise_validation_exception()
 
         # If no exceptions are raised, assume ARN and referenced resource is valid for tag operations
         return lambda_stores[account_id][region]