Merge branch 'main' into sebsto/servicelifecycle

Author: sebsto

.github/workflows/integration_tests.yml

@@ -19,6 +19,11 @@ on:
         type: boolean
         description: "Boolean to enable the compilation of examples. Defaults to true."
         default: true
+      archive_plugin_examples:
+        type: string
+        description: "The list of examples to run through the archive plugin test. Pass a String with a valid JSON array such as \"[ 'HelloWorld', 'APIGateway' ]\""
+        required: true
+        default: ""
       archive_plugin_enabled:
         type: boolean
         description: "Boolean to enable the test of the archive plugin. Defaults to true."
@@ -54,7 +59,7 @@ jobs:
         # We are using only one Swift version
         swift:
           - image: ${{ inputs.matrix_linux_swift_container_image }}
-            swift_version: "6.0.1-amazonlinux2"
+            swift_version: "6.0.3-amazonlinux2"
     container:
       image: ${{ matrix.swift.image }}
     steps:
@@ -98,6 +103,10 @@ jobs:
     name: Test archive plugin
     if: ${{ inputs.archive_plugin_enabled }}
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        examples: ${{ fromJson(inputs.archive_plugin_examples) }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -107,8 +116,10 @@ jobs:
         # https://github.com/actions/checkout/issues/766
         run: git config --global --add safe.directory ${GITHUB_WORKSPACE}
       - name: Test the archive plugin
+        env:
+          EXAMPLE: ${{ matrix.examples }}
         run: |
-          .github/workflows/scripts/check-archive-plugin.sh
+            .github/workflows/scripts/check-archive-plugin.sh
 
   check-foundation:
     name: No dependencies on Foundation

.github/workflows/pull_request.yml

@@ -36,8 +36,8 @@ jobs:
       # We pass the list of examples here, but we can't pass an array as argument
       # Instead, we pass a String with a valid JSON array.
       # The workaround is mentioned here https://github.com/orgs/community/discussions/11692
-      examples: "[ 'APIGateway', 'APIGateway+LambdaAuthorizer', 'BackgroundTasks', 'HelloJSON', 'HelloWorld', 'S3_AWSSDK', 'S3_Soto', 'Streaming', 'Testing', 'Tutorial' ]"
-
+      examples: "[ 'APIGateway', 'APIGateway+LambdaAuthorizer', 'BackgroundTasks', 'HelloJSON', 'HelloWorld', 'ResourcesPackaging', 'S3_AWSSDK', 'S3_Soto', 'Streaming', 'Testing', 'Tutorial' ]"
+      archive_plugin_examples: "[ 'HelloWorld', 'ResourcesPackaging' ]"
       archive_plugin_enabled: true
 
   swift-6-language-mode:

.github/workflows/scripts/check-archive-plugin.sh

@@ -13,12 +13,17 @@
 ##
 ##===----------------------------------------------------------------------===##
 
-EXAMPLE=HelloWorld
+log() { printf -- "** %s\n" "$*" >&2; }
+error() { printf -- "** ERROR: %s\n" "$*" >&2; }
+fatal() { error "$@"; exit 1; }
+
+test -n "${EXAMPLE:-}" || fatal "EXAMPLE unset"
+
 OUTPUT_DIR=.build/plugins/AWSLambdaPackager/outputs/AWSLambdaPackager
 OUTPUT_FILE=${OUTPUT_DIR}/MyLambda/bootstrap
 ZIP_FILE=${OUTPUT_DIR}/MyLambda/MyLambda.zip
 
-pushd Examples/${EXAMPLE} || exit 1
+pushd "Examples/${EXAMPLE}" || exit 1
 
 # package the example (docker and swift toolchain are installed on the GH runner)
 LAMBDA_USE_LOCAL_DEPS=../.. swift package archive --allow-network-connections docker || exit 1
@@ -33,5 +38,10 @@ file "${OUTPUT_FILE}" | grep --silent ELF
 # does the ZIP file contain the bootstrap?
 unzip -l "${ZIP_FILE}" | grep --silent bootstrap
 
-echo "✅ The archive plugin is OK"
+# if EXAMPLE is ResourcesPackaging, check if the ZIP file contains hello.txt
+if [ "$EXAMPLE" == "ResourcesPackaging" ]; then
+    unzip -l "${ZIP_FILE}" | grep --silent hello.txt
+fi    
+
+echo "✅ The archive plugin is OK with example ${EXAMPLE}"
 popd || exit 1

.licenseignore

@@ -33,4 +33,5 @@ Package.resolved
 *.yaml
 *.yml
 **/.npmignore
-**/*.json
+**/*.json
+**/*.txt

Examples/CDK/infra/package-lock.json

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

Examples/ResourcesPackaging/.gitignore

@@ -0,0 +1,57 @@
+// swift-tools-version: 6.0
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+// needed for CI to test the local version of the library
+import struct Foundation.URL
+
+let package = Package(
+    name: "ResourcesPackaging",
+    platforms: [.macOS(.v15)],
+    products: [
+        .executable(name: "MyLambda", targets: ["MyLambda"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", branch: "main")
+    ],
+    targets: [
+        .executableTarget(
+            name: "MyLambda",
+            dependencies: [
+                .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime")
+            ],
+            path: ".",
+            resources: [
+                .process("hello.txt")
+            ]
+        )
+    ]
+)
+
+if let localDepsPath = Context.environment["LAMBDA_USE_LOCAL_DEPS"],
+    localDepsPath != "",
+    let v = try? URL(fileURLWithPath: localDepsPath).resourceValues(forKeys: [.isDirectoryKey]),
+    v.isDirectory == true
+{
+    // when we use the local runtime as deps, let's remove the dependency added above
+    let indexToRemove = package.dependencies.firstIndex { dependency in
+        if case .sourceControl(
+            name: _,
+            location: "https://github.com/swift-server/swift-aws-lambda-runtime.git",
+            requirement: _
+        ) = dependency.kind {
+            return true
+        }
+        return false
+    }
+    if let indexToRemove {
+        package.dependencies.remove(at: indexToRemove)
+    }
+
+    // then we add the dependency on LAMBDA_USE_LOCAL_DEPS' path (typically ../..)
+    print("[INFO] Compiling against swift-aws-lambda-runtime located at \(localDepsPath)")
+    package.dependencies += [
+        .package(name: "swift-aws-lambda-runtime", path: localDepsPath)
+    ]
+}

Examples/ResourcesPackaging/Package.swift

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2025 Apple Inc. and the SwiftAWSLambdaRuntime project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftAWSLambdaRuntime project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import AWSLambdaRuntime
+import Foundation
+
+let runtime = LambdaRuntime {
+    (event: String, context: LambdaContext) in
+    guard let fileURL = Bundle.module.url(forResource: "hello", withExtension: "txt") else {
+        fatalError("no file url")
+    }
+    return try String(contentsOf: fileURL, encoding: .utf8)
+}
+
+try await runtime.run()

Examples/ResourcesPackaging/Sources/main.swift

@@ -0,0 +1 @@
+Hello World

Examples/ResourcesPackaging/hello.txt

@@ -23,7 +23,7 @@ let package = Package(
         .library(name: "AWSLambdaTesting", targets: ["AWSLambdaTesting"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-nio.git", from: "2.76.0"),
+        .package(url: "https://github.com/apple/swift-nio.git", from: "2.77.0"),
         .package(url: "https://github.com/apple/swift-log.git", from: "1.5.4"),
         .package(url: "https://github.com/swift-server/swift-service-lifecycle.git", from: "2.6.3"),
     ],
@@ -103,11 +103,11 @@ let package = Package(
         .executableTarget(
             name: "MockServer",
             dependencies: [
+                .product(name: "Logging", package: "swift-log"),
                 .product(name: "NIOHTTP1", package: "swift-nio"),
                 .product(name: "NIOCore", package: "swift-nio"),
                 .product(name: "NIOPosix", package: "swift-nio"),
-            ],
-            swiftSettings: [.swiftLanguageMode(.v5)]
+            ]
         ),
     ]
 )

Package.swift

@@ -249,11 +249,29 @@ struct AWSLambdaPackager: CommandPlugin {
                 let resourcesDirectoryName = artifactURL.lastPathComponent
                 let relocatedResourcesDirectory = workingDirectory.appending(path: resourcesDirectoryName)
                 if FileManager.default.fileExists(atPath: artifactURL.path()) {
-                    try FileManager.default.copyItem(
-                        atPath: artifactURL.path(),
-                        toPath: relocatedResourcesDirectory.path()
-                    )
-                    arguments.append(resourcesDirectoryName)
+                    do {
+                        try FileManager.default.copyItem(
+                            atPath: artifactURL.path(),
+                            toPath: relocatedResourcesDirectory.path()
+                        )
+                        arguments.append(resourcesDirectoryName)
+                    } catch let error as CocoaError {
+
+                        // On Linux, when the build has been done with Docker,
+                        // the source file are owned by root
+                        // this causes a permission error **after** the files have been copied
+                        // see https://github.com/swift-server/swift-aws-lambda-runtime/issues/449
+                        // see https://forums.swift.org/t/filemanager-copyitem-on-linux-fails-after-copying-the-files/77282
+
+                        // because this error happens after the files have been copied, we can ignore it
+                        // this code checks if the destination file exists
+                        // if they do, just ignore error, otherwise throw it up to the caller.
+                        if !(error.code == CocoaError.Code.fileWriteNoPermission
+                            && FileManager.default.fileExists(atPath: relocatedResourcesDirectory.path()))
+                        {
+                            throw error
+                        }  // else just ignore it
+                    }
                 }
             }
 

Plugins/AWSLambdaPackager/Plugin.swift

@@ -0,0 +1,298 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2017-2025 Apple Inc. and the SwiftAWSLambdaRuntime project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftAWSLambdaRuntime project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import Logging
+import NIOCore
+import NIOHTTP1
+import NIOPosix
+import Synchronization
+
+// for UUID and Date
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
+@main
+struct HttpServer {
+    /// The server's host. (default: 127.0.0.1)
+    private let host: String
+    /// The server's port. (default: 7000)
+    private let port: Int
+    /// The server's event loop group. (default: MultiThreadedEventLoopGroup.singleton)
+    private let eventLoopGroup: MultiThreadedEventLoopGroup
+    /// the mode. Are we mocking a server for a Lambda function that expects a String or a JSON document? (default: string)
+    private let mode: Mode
+    /// the number of connections this server must accept before shutting down (default: 1)
+    private let maxInvocations: Int
+    /// the logger (control verbosity with LOG_LEVEL environment variable)
+    private let logger: Logger
+
+    static func main() async throws {
+        var log = Logger(label: "MockServer")
+        log.logLevel = env("LOG_LEVEL").flatMap(Logger.Level.init) ?? .info
+
+        let server = HttpServer(
+            host: env("HOST") ?? "127.0.0.1",
+            port: env("PORT").flatMap(Int.init) ?? 7000,
+            eventLoopGroup: .singleton,
+            mode: env("MODE").flatMap(Mode.init) ?? .string,
+            maxInvocations: env("MAX_INVOCATIONS").flatMap(Int.init) ?? 1,
+            logger: log
+        )
+        try await server.run()
+    }
+
+    /// This method starts the server and handles one unique incoming connections
+    /// The Lambda function will send two HTTP requests over this connection: one for the next invocation and one for the response.
+    private func run() async throws {
+        let channel = try await ServerBootstrap(group: self.eventLoopGroup)
+            .serverChannelOption(.backlog, value: 256)
+            .serverChannelOption(.socketOption(.so_reuseaddr), value: 1)
+            .childChannelOption(.maxMessagesPerRead, value: 1)
+            .bind(
+                host: self.host,
+                port: self.port
+            ) { channel in
+                channel.eventLoop.makeCompletedFuture {
+
+                    try channel.pipeline.syncOperations.configureHTTPServerPipeline(
+                        withErrorHandling: true
+                    )
+
+                    return try NIOAsyncChannel(
+                        wrappingChannelSynchronously: channel,
+                        configuration: NIOAsyncChannel.Configuration(
+                            inboundType: HTTPServerRequestPart.self,
+                            outboundType: HTTPServerResponsePart.self
+                        )
+                    )
+                }
+            }
+
+        logger.info(
+            "Server started and listening",
+            metadata: [
+                "host": "\(channel.channel.localAddress?.ipAddress?.debugDescription ?? "")",
+                "port": "\(channel.channel.localAddress?.port ?? 0)",
+                "maxInvocations": "\(self.maxInvocations)",
+            ]
+        )
+
+        // This counter is used to track the number of incoming connections.
+        // This mock servers accepts n TCP connection then shutdowns
+        let connectionCounter = SharedCounter(maxValue: self.maxInvocations)
+
+        // We are handling each incoming connection in a separate child task. It is important
+        // to use a discarding task group here which automatically discards finished child tasks.
+        // A normal task group retains all child tasks and their outputs in memory until they are
+        // consumed by iterating the group or by exiting the group. Since, we are never consuming
+        // the results of the group we need the group to automatically discard them; otherwise, this
+        // would result in a memory leak over time.
+        try await withThrowingDiscardingTaskGroup { group in
+            try await channel.executeThenClose { inbound in
+                for try await connectionChannel in inbound {
+
+                    let counter = connectionCounter.current()
+                    logger.trace("Handling new connection", metadata: ["connectionNumber": "\(counter)"])
+
+                    group.addTask {
+                        await self.handleConnection(channel: connectionChannel)
+                        logger.trace("Done handling connection", metadata: ["connectionNumber": "\(counter)"])
+                    }
+
+                    if connectionCounter.increment() {
+                        logger.info(
+                            "Maximum number of connections reached, shutting down after current connection",
+                            metadata: ["maxConnections": "\(self.maxInvocations)"]
+                        )
+                        break  // this causes the server to shutdown after handling the connection
+                    }
+                }
+            }
+        }
+        logger.info("Server shutting down")
+    }
+
+    /// This method handles a single connection by responsing hard coded value to a Lambda function request.
+    /// It handles two requests: one for the next invocation and one for the response.
+    /// when the maximum number of requests is reached, it closes the connection.
+    private func handleConnection(
+        channel: NIOAsyncChannel<HTTPServerRequestPart, HTTPServerResponsePart>
+    ) async {
+
+        var requestHead: HTTPRequestHead!
+        var requestBody: ByteBuffer?
+
+        // each Lambda invocation results in TWO HTTP requests (next and response)
+        let requestCount = SharedCounter(maxValue: 2)
+
+        // Note that this method is non-throwing and we are catching any error.
+        // We do this since we don't want to tear down the whole server when a single connection
+        // encounters an error.
+        do {
+            try await channel.executeThenClose { inbound, outbound in
+                for try await inboundData in inbound {
+                    let requestNumber = requestCount.current()
+                    logger.trace("Handling request", metadata: ["requestNumber": "\(requestNumber)"])
+
+                    if case .head(let head) = inboundData {
+                        logger.trace("Received request head", metadata: ["head": "\(head)"])
+                        requestHead = head
+                    }
+                    if case .body(let body) = inboundData {
+                        logger.trace("Received request body", metadata: ["body": "\(body)"])
+                        requestBody = body
+                    }
+                    if case .end(let end) = inboundData {
+                        logger.trace("Received request end", metadata: ["end": "\(String(describing: end))"])
+
+                        precondition(requestHead != nil, "Received .end without .head")
+                        let (responseStatus, responseHeaders, responseBody) = self.processRequest(
+                            requestHead: requestHead,
+                            requestBody: requestBody
+                        )
+
+                        try await self.sendResponse(
+                            responseStatus: responseStatus,
+                            responseHeaders: responseHeaders,
+                            responseBody: responseBody,
+                            outbound: outbound
+                        )
+
+                        requestHead = nil
+
+                        if requestCount.increment() {
+                            logger.info(
+                                "Maximum number of requests reached, closing this connection",
+                                metadata: ["maxRequest": "2"]
+                            )
+                            break  // this finishes handiling request on this connection
+                        }
+                    }
+                }
+            }
+        } catch {
+            logger.error("Hit error: \(error)")
+        }
+    }
+    /// This function process the requests and return an hard-coded response (string or JSON depending on the mode).
+    /// We ignore the requestBody.
+    private func processRequest(
+        requestHead: HTTPRequestHead,
+        requestBody: ByteBuffer?
+    ) -> (HTTPResponseStatus, [(String, String)], String) {
+        var responseStatus: HTTPResponseStatus = .ok
+        var responseBody: String = ""
+        var responseHeaders: [(String, String)] = []
+
+        logger.trace(
+            "Processing request",
+            metadata: ["VERB": "\(requestHead.method)", "URI": "\(requestHead.uri)"]
+        )
+
+        if requestHead.uri.hasSuffix("/next") {
+            responseStatus = .accepted
+
+            let requestId = UUID().uuidString
+            switch self.mode {
+            case .string:
+                responseBody = "\"Seb\""  // must be a valid JSON document
+            case .json:
+                responseBody = "{ \"name\": \"Seb\", \"age\" : 52 }"
+            }
+            let deadline = Int64(Date(timeIntervalSinceNow: 60).timeIntervalSince1970 * 1000)
+            responseHeaders = [
+                (AmazonHeaders.requestID, requestId),
+                (AmazonHeaders.invokedFunctionARN, "arn:aws:lambda:us-east-1:123456789012:function:custom-runtime"),
+                (AmazonHeaders.traceID, "Root=1-5bef4de7-ad49b0e87f6ef6c87fc2e700;Parent=9a9197af755a6419;Sampled=1"),
+                (AmazonHeaders.deadline, String(deadline)),
+            ]
+        } else if requestHead.uri.hasSuffix("/response") {
+            responseStatus = .accepted
+        } else if requestHead.uri.hasSuffix("/error") {
+            responseStatus = .ok
+        } else {
+            responseStatus = .notFound
+        }
+        logger.trace("Returning response: \(responseStatus), \(responseHeaders), \(responseBody)")
+        return (responseStatus, responseHeaders, responseBody)
+    }
+
+    private func sendResponse(
+        responseStatus: HTTPResponseStatus,
+        responseHeaders: [(String, String)],
+        responseBody: String,
+        outbound: NIOAsyncChannelOutboundWriter<HTTPServerResponsePart>
+    ) async throws {
+        var headers = HTTPHeaders(responseHeaders)
+        headers.add(name: "Content-Length", value: "\(responseBody.utf8.count)")
+        headers.add(name: "KeepAlive", value: "timeout=1, max=2")
+
+        logger.trace("Writing response head")
+        try await outbound.write(
+            HTTPServerResponsePart.head(
+                HTTPResponseHead(
+                    version: .init(major: 1, minor: 1),  // use HTTP 1.1 it keeps connection alive between requests
+                    status: responseStatus,
+                    headers: headers
+                )
+            )
+        )
+        logger.trace("Writing response body")
+        try await outbound.write(HTTPServerResponsePart.body(.byteBuffer(ByteBuffer(string: responseBody))))
+        logger.trace("Writing response end")
+        try await outbound.write(HTTPServerResponsePart.end(nil))
+    }
+
+    private enum Mode: String {
+        case string
+        case json
+    }
+
+    private static func env(_ name: String) -> String? {
+        guard let value = getenv(name) else {
+            return nil
+        }
+        return String(cString: value)
+    }
+
+    private enum AmazonHeaders {
+        static let requestID = "Lambda-Runtime-Aws-Request-Id"
+        static let traceID = "Lambda-Runtime-Trace-Id"
+        static let clientContext = "X-Amz-Client-Context"
+        static let cognitoIdentity = "X-Amz-Cognito-Identity"
+        static let deadline = "Lambda-Runtime-Deadline-Ms"
+        static let invokedFunctionARN = "Lambda-Runtime-Invoked-Function-Arn"
+    }
+
+    private final class SharedCounter: Sendable {
+        private let counterMutex = Mutex<Int>(0)
+        private let maxValue: Int
+
+        init(maxValue: Int) {
+            self.maxValue = maxValue
+        }
+        func current() -> Int {
+            counterMutex.withLock { $0 }
+        }
+        func increment() -> Bool {
+            counterMutex.withLock {
+                $0 += 1
+                return $0 >= maxValue
+            }
+        }
+    }
+}

Sources/AWSLambdaRuntimeCore/Documentation.docc/img/deployment/console-10-regions.png renamed to Sources/AWSLambdaRuntimeCore/Documentation.docc/Resources/deployment/console-10-regions.png

@@ -1,9 +1,6 @@
 > [!IMPORTANT]
 > The documentation included here refers to the Swift AWS Lambda Runtime v2 (code from the main branch). If you're developing for the runtime v1.x, check this [readme](https://github.com/swift-server/swift-aws-lambda-runtime/blob/v1/readme.md) instead.
 
-> [!WARNING]
-> The Swift AWS Runtime v2 is work in progress. We will add more documentation and code examples over time.
-
 This guide contains the follwoing sections:
 
 - [The Swift AWS Lambda Runtime](#the-swift-aws-lambda-runtime)
@@ -282,7 +279,7 @@ try await runtime.run()
 
 ### Integration with Swift Service LifeCycle
 
-tbd + link to docc
+Support for [Swift Service Lifecycle](https://github.com/swift-server/swift-service-lifecycle) is currently being implemented. You can follow https://github.com/swift-server/swift-aws-lambda-runtime/issues/374 for more details and teh current status. Your contributions are welcome.
 
 ### Use Lambda Background Tasks
 

Sources/AWSLambdaRuntimeCore/Documentation.docc/img/deployment/console-20-dashboard.png renamed to Sources/AWSLambdaRuntimeCore/Documentation.docc/Resources/deployment/console-20-dashboard.png

@@ -0,0 +1,70 @@
+#!/bin/bash
+##===----------------------------------------------------------------------===##
+##
+## This source file is part of the SwiftAWSLambdaRuntime open source project
+##
+## Copyright (c) 2025 Apple Inc. and the SwiftAWSLambdaRuntime project authors
+## Licensed under Apache License v2.0
+##
+## See LICENSE.txt for license information
+## See CONTRIBUTORS.txt for the list of SwiftAWSLambdaRuntime project authors
+##
+## SPDX-License-Identifier: Apache-2.0
+##
+##===----------------------------------------------------------------------===##
+
+sudo apt update && sudo apt -y upgrade
+
+# Install Swift 6.0.3
+sudo apt-get -y install \
+          binutils \
+          git \
+          gnupg2 \
+          libc6-dev \
+          libcurl4-openssl-dev \
+          libedit2 \
+          libgcc-13-dev \
+          libncurses-dev \
+          libpython3-dev \
+          libsqlite3-0 \
+          libstdc++-13-dev \
+          libxml2-dev \
+          libz3-dev \
+          pkg-config \
+          tzdata \
+          unzip \
+          zip \
+          zlib1g-dev
+
+wget https://download.swift.org/swift-6.0.3-release/ubuntu2404-aarch64/swift-6.0.3-RELEASE/swift-6.0.3-RELEASE-ubuntu24.04-aarch64.tar.gz
+
+tar xfvz swift-6.0.3-RELEASE-ubuntu24.04-aarch64.tar.gz
+
+export PATH=/home/ubuntu/swift-6.0.3-RELEASE-ubuntu24.04-aarch64/usr/bin:"${PATH}"
+
+swift --version
+
+# Install Docker
+sudo apt-get update
+sudo apt-get install -y ca-certificates curl
+sudo install -m 0755 -d /etc/apt/keyrings
+sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
+sudo chmod a+r /etc/apt/keyrings/docker.asc
+
+# Add the repository to Apt sources:
+# shellcheck source=/etc/os-release
+# shellcheck disable=SC1091
+. /etc/os-release
+echo \
+  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
+  $VERSION_CODENAME stable" | \
+  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+sudo apt-get update
+
+sudo apt-get -y install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+
+# Add the current user to the docker group
+sudo usermod -aG docker "$USER"
+
+# LOGOUT and LOGIN to apply the changes
+exit 0

Sources/AWSLambdaRuntimeCore/Documentation.docc/img/deployment/console-30-create-function.png renamed to Sources/AWSLambdaRuntimeCore/Documentation.docc/Resources/deployment/console-30-create-function.png

@@ -0,0 +1,28 @@
+#!/bin/bash
+##===----------------------------------------------------------------------===##
+##
+## This source file is part of the SwiftAWSLambdaRuntime open source project
+##
+## Copyright (c) 2025 Apple Inc. and the SwiftAWSLambdaRuntime project authors
+## Licensed under Apache License v2.0
+##
+## See LICENSE.txt for license information
+## See CONTRIBUTORS.txt for the list of SwiftAWSLambdaRuntime project authors
+##
+## SPDX-License-Identifier: Apache-2.0
+##
+##===----------------------------------------------------------------------===##
+
+# Connect with ssh 
+
+export PATH=/home/ubuntu/swift-6.0.3-RELEASE-ubuntu24.04-aarch64/usr/bin:"${PATH}"
+
+# clone a project 
+git clone https://github.com/swift-server/swift-aws-lambda-runtime.git
+
+# be sure Swift is install.  
+# Youc an install swift with the following command: ./scripts/ubuntu-install-swift.sh
+
+# build the project
+cd swift-aws-lambda-runtime/Examples/ResourcesPackaging/ || exit 1
+LAMBDA_USE_LOCAL_DEPS=../.. swift package archive --allow-network-connections docker