Starting today, Swift developers who write code for Apple platforms (iOS, iPadOS, macOS, tvOS, watchOS, or visionOS) or for Swift applications running on the server side can use AWS CodeArtifact to securely store and retrieve their package dependencies. CodeArtifact integrates with standard developer tools such as Xcode, xcodebuild, and the Swift Package Manager (the swift package command).
Simple applications routinely include dozens of packages. Large enterprise applications might have hundreds of dependencies. These packages help developers speed up the development and testing process by providing code that solves common programming challenges such as network access, cryptographic functions, or data format manipulation. Developers also embed SDKs–such as the AWS SDKs–to access remote services. These packages might be produced by other teams in your organization or maintained by third-parties, such as open-source projects. Managing packages and their dependencies is an integral part of the software development process. Modern programming languages include tools to download and resolve dependencies: Maven in Java, NuGet in C#, npm or yarn in JavaScript, and pip in Python just to mention a few. Developers for Apple platforms use CocoaPods or the Swift Package Manager (SwiftPM).
Downloading and integrating packages is a routine operation for application developers. However, it presents at least two significant challenges for organizations.
The first challenge is legal. Organizations must ensure that licenses for third-party packages are compatible with the expected use of licenses for your specific project and that the package doesn’t violate someone else’s intellectual property (IP). The second challenge is security. Organizations must ensure that the included code is safe to use and doesn’t include back doors or intentional vulnerabilities designed to introduce security flaws in your app. Injecting vulnerabilities in popular open-source projects is known as a supply chain attack and has become increasingly popular in recent years.
To address these challenges, organizations typically install private package servers on premises or in the cloud. Developers can only use packages vetted by their organization’s security and legal teams and made available through private repositories.
AWS CodeArtifact is a managed service that allows you to safely distribute packages to your internal teams of developers. There is no need to install, manage, or scale the underlying infrastructure. We take care of that for you, giving you more time to work on your apps instead of the software development infrastructure.
I’m excited to announce that CodeArtifact now supports native Swift packages, in addition to npm, PyPI, Maven, NuGet, and generic package formats. Swift packages are a popular way to package and distribute reusable Swift code elements. To learn how to create your own Swift package, you can follow this tutorial. The community has also created more than 6,000 Swift packages that you can use in your Swift applications.
You can now publish and download your Swift package dependencies from your CodeArtifact repository in the AWS Cloud. CodeArtifact SwiftPM works with existing developer tools such as Xcode, VSCode, and the Swift Package Manager command line tool. After your packages are stored in CodeArtifact, you can reference them in your project’s Package.swift file or in your Xcode project, in a similar way you use Git endpoints to access public Swift packages.
After the configuration is complete, your network-jailed build system will download the packages from the CodeArtifact repository, ensuring that only approved and controlled packages are used during your application’s build process.
How To Get Started
As usual on this blog, I’ll show you how it works. Imagine I’m working on an iOS application that uses Amazon DynamoDB as a database. My application embeds the AWS SDK for Swift as a dependency. To comply with my organization policies, the application must use a specific version of the AWS SDK for Swift, compiled in-house and approved by my organization’s legal and security teams. In this demo, I show you how I prepare my environment, upload the package to the repository, and use this specific package build as a dependency for my project.
For this demo, I focus on the steps specific to Swift packages. You can read the tutorial written by my colleague Steven to get started with CodeArtifact.
I use an AWS account that has a package repository (MySwiftRepo) and domain (stormacq-test) already configured.
To let SwiftPM acess my CodeArtifact repository, I start by collecting an authentication token from CodeArtifact.
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token \
--domain stormacq-test \
--domain-owner 012345678912 \
--query authorizationToken \
--output text`Note that the authentication token expires after 12 hours. I must repeat this command after 12 hours to obtain a fresh token.
Then, I request the repository endpoint. I pass the domain name and domain owner (the AWS account ID). Notice the --format swift option.
export CODEARTIFACT_REPO=`aws codeartifact get-repository-endpoint \
--domain stormacq-test \
--domain-owner 012345678912 \
--format swift \
--repository MySwiftRepo \
--query repositoryEndpoint \
--output text`Now that I have the repository endpoint and an authentication token, I use the AWS Command Line Interface (AWS CLI) to configure SwiftPM on my machine.
SwiftPM can store the repository configurations at user level (in the file ~/.swiftpm/configurations) or at project level (in the file <your project>/.swiftpm/configurations). By default, the CodeArtifact login command creates a project-level configuration to allow you to use different CodeArtifact repositories for different projects.
I use the AWS CLI to configure SwiftPM on my build machine.
aws codeartifact login \
--tool swift \
--domain stormacq-test \
--repository MySwiftRepo \
--namespace aws \
--domain-owner 012345678912The command invokes swift package-registry login with the correct options, which in turn, creates the required SwiftPM configuration files with the given repository name (MySwiftRepo) and scope name (aws).
Now that my build machine is ready, I prepare my organization’s approved version of the AWS SDK for Swift package and then I upload it to the repository.
git clone https://github.com/awslabs/aws-sdk-swift.git
pushd aws-sdk-swift
swift package archive-source
mv aws-sdk-swift.zip ../aws-sdk-swift-0.24.0.zip
popdFinally, I upload this package version to the repository.
When using Swift 5.9 or more recent, I can upload my package to my private repository using the SwiftPM command:
swift package-registry publish \
aws.aws-sdk-swift \
0.24.0 \
--verboseThe versions of Swift before 5.9 don’t provide a swift package-registry publish command. So, I use the curl command instead.
curl -X PUT
--user "aws:$CODEARTIFACT_AUTH_TOKEN" \
-H "Accept: application/vnd.swift.registry.v1+json" \
-F source-archive="@aws-sdk-swift-0.24.0.zip" \
"${CODEARTIFACT_REPO}aws/aws-sdk-swift/0.24.0"Notice the format of the package name after the URI of the repository: <scope>/<package name>/<package version>. The package version must follow the semantic versioning scheme.
I can use the CLI or the console to verify that the package is available in the repository.
aws codeartifact list-package-versions \
--domain stormacq-test \
--repository MySwiftRepo \
--format swift \
--namespace aws \
--package aws-sdk-swift
{
"versions": [
{
"version": "0.24.0",
"revision": "6XB5O65J8J3jkTDZd8RMLyqz7XbxIg9IXpTudP7THbU=",
"status": "Published",
"origin": {
"domainEntryPoint": {
"repositoryName": "MySwiftRepo"
},
"originType": "INTERNAL"
}
}
],
"defaultDisplayVersion": "0.24.0",
"format": "swift",
"package": "aws-sdk-swift",
"namespace": "aws"
}
Now that the package is available, I can use it in my projects as usual.
Xcode uses SwiftPM tools and configuration files I just created. To add a package to my Xcode project, I select the project name on the left pane, and then I select the Package Dependencies tab. I can see the packages that are already part of my project. To add a private package, I choose the + sign under Packages.
On the top right search field, I enter aws.aws-sdk-swift (this is <scope name>.<package name>). After a second or two, the package name appears on the list. On the top right side, you can verify the source repository (next to the Registry label). Before selecting the Add Package button, select the version of the package, just like you do for publicly available packages.
Alternatively, for my server-side or command-line applications, I add the dependency in the Package.swift file. I also use the format (<scope>.<package name>) as the first parameter of .package(id:from:)function.
dependencies: [
.package(id: "aws.aws-sdk-swift", from: "0.24.0")
],
When I type swift package update, SwiftPM downloads the package from the CodeArtifact repository.
Things to Know
There are some things to keep in mind before uploading your first Swift packages.
- Be sure to update to the latest version of the CLI before trying any command shown in the preceding instructions.
- You have to use Swift version 5.8 or newer to use CodeArtifact with the
swift packagecommand. On macOS, the Swift toolchain comes with Xcode. Swift 5.8 is available on macOS 13 (Ventura) and Xcode 14. On Linux and Windows, you can download the Swift toolchain from swift.org. - You have to use Xcode 15 for your iOS, iPadOS, tvOS, or watchOS applications. I tested this with Xcode 15 beta8.
- The
swift package-registry publishcommand is available with Swift 5.9 or newer. When you use Swift 5.8, you can usecurlto upload your package, as I showed in the demo (or use any HTTP client of your choice). - Swift packages have the concept of scope. A scope provides a namespace for related packages within a package repository. Scopes are mapped to CodeArtifact namespaces.
- The authentication token expires after 12 hours. We suggest writing a script to automate its renewal or using a scheduled AWS Lambda function and securely storing the token in AWS Secrets Manager (for example).
Troubleshooting
If Xcode can not find your private package, double-check the registry configuration in ~/.swiftpm/configurations/registries.json. In particular, check if the scope name is present. Also verify that the authentication token is present in the keychain. The name of the entry is the URL of your repository. You can verify the entries in the keychain with the /Application/Utilities/Keychain Access.app application or using the security command line tool.
security find-internet-password \
-s "stormacq-test-012345678912.d.codeartifact.us-west-2.amazonaws.com" \
-gHere is the SwiftPM configuration on my machine.
cat ~/.swiftpm/configuration/registries.json
{
"authentication" : {
"stormacq-test-012345678912.d.codeartifact.us-west-2.amazonaws.com" : {
"loginAPIPath" : "/swift/MySwiftRepo/login",
"type" : "token"
}
},
"registries" : {
"aws" : { // <-- this is the scope name!
"url" : "https://stormacq-test-012345678912.d.codeartifact.us-west-2.amazonaws.com/swift/MySwiftRepo/"
}
},
"version" : 1
}
Pricing and Availability
CodeArtifact costs for Swift packages are the same as for the other package formats already supported. CodeArtifact billing depends on three metrics: the storage (measured in GB per month), the number of requests, and the data transfer out to the internet or to other AWS Regions. Data transfer to AWS services in the same Region is not charged, meaning you can run your CICD jobs on Amazon EC2 Mac instances, for example, without incurring a charge for the CodeArtifact data transfer. As usual, the pricing page has the details.
CodeArtifact for Swift packages is available in all 13 Regions where CodeArtifact is available.
Now go build your Swift applications and upload your private packages to CodeArtifact!
PS : Do you know you can write Lambda functions in the Swift programming language? Check the quick start guide or follow this 35-minute tutorial.
from AWS News Blog https://ift.tt/aFiBTeR
Share this content: