diff --git a/.github/workflows/build_changelog.yml b/.github/workflows/build_changelog.yml index b14c38c39a5..ffa6163ca03 100644 --- a/.github/workflows/build_changelog.yml +++ b/.github/workflows/build_changelog.yml @@ -17,8 +17,8 @@ on: # branches: # - develop schedule: - # Note: run daily at 7am UTC time until upstream git-chlog uses stable sorting - - cron: "0 7 * * *" + # Note: run daily at 10am UTC time until upstream git-chlog uses stable sorting + - cron: "0 10 * * *" permissions: contents: read diff --git a/.github/workflows/pre-release.yml b/.github/workflows/pre-release.yml new file mode 100644 index 00000000000..6d4064e4b8e --- /dev/null +++ b/.github/workflows/pre-release.yml @@ -0,0 +1,278 @@ +name: Pre-Release + +# PRE-RELEASE PROCESS +# +# === Automated activities === +# +# 1. [Seal] Bump to release version and export source code with integrity hash +# 2. [Quality check] Restore sealed source code, run tests, linting, security and complexity base line +# 3. [Build] Restore sealed source code, create and export hashed build artifact for PyPi release (wheel, tarball) +# 4. [Provenance] Generates provenance for build, signs attestation with GitHub OIDC claims to confirm it came from this release pipeline, commit, org, repo, branch, hash, etc. +# 5. [Release] Restore built artifact, and publish package to PyPi prod repository +# 6. [PR to bump version] Restore sealed source code, and create a PR to update trunk with latest released project metadata + +# NOTE +# +# See MAINTAINERS.md "Releasing a new version" for release mechanisms +# +# Every job is isolated and starts a new fresh container. + +env: + RELEASE_COMMIT: ${{ github.sha }} + +on: + workflow_dispatch: + inputs: + skip_code_quality: + description: "Skip tests, linting, and baseline. Only use if release fail for reasons beyond our control and you need a quick release." + default: false + type: boolean + required: false + skip_pypi: + description: "Skip publishing to PyPi. Used for testing release steps." + default: false + type: boolean + required: false + schedule: + # Note: run daily at 8am UTC time + - cron: "0 8 * * *" + +permissions: + contents: read + +jobs: + + # This job bumps the package version to the pre-release version + # creates an integrity hash from the source code + # uploads the artifact with the integrity hash as the key name + # so subsequent jobs can restore from a trusted point in time to prevent tampering + seal: + # ignore forks + # if: github.repository == 'aws-powertools/powertools-lambda-python' + + runs-on: ubuntu-latest + permissions: + contents: read + outputs: + integrity_hash: ${{ steps.seal_source_code.outputs.integrity_hash }} + artifact_name: ${{ steps.seal_source_code.outputs.artifact_name }} + RELEASE_VERSION: ${{ steps.release_version.outputs.RELEASE_VERSION }} + steps: + # NOTE: Different from prod release, we need both poetry and source code available in earlier steps to bump and verify. + + # We use a pinned version of Poetry to be certain it won't modify source code before we create a hash + - name: Install poetry + run: | + pipx install git+https://github.com/python-poetry/poetry@68b88e5390720a3dd84f02940ec5200bfce39ac6 # v1.5.0 + pipx inject poetry git+https://github.com/monim67/poetry-bumpversion@315fe3324a699fa12ec20e202eb7375d4327d1c4 # v0.3.1 + + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + with: + ref: ${{ env.RELEASE_COMMIT }} + + - name: Export release version + id: release_version + run: | + RELEASE_VERSION="$(poetry version prerelease --short | head -n1 | tr -d '\n')" + + echo "RELEASE_VERSION=${RELEASE_VERSION}" >> "$GITHUB_OUTPUT" + + - name: Verifies pre-release version semantics + # verify pre-release semantics before proceeding to avoid versioning pollution + # e.g., 2.40.0a1 and 2.40.0b2 are valid while 2.40.0 is not + run: | + if [[ ! "$RELEASE_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+[a-b].*$ ]]; then + echo "Version $VERSION doesn't look like a pre-release version; aborting" + exit 1 + fi + env: + RELEASE_VERSION: ${{ steps.release_version.outputs.RELEASE_VERSION}} + + - name: Bump package version + id: versioning + run: poetry version "${RELEASE_VERSION}" + env: + RELEASE_VERSION: ${{ steps.release_version.outputs.RELEASE_VERSION}} + + - name: Seal and upload + id: seal_source_code + uses: ./.github/actions/seal + with: + artifact_name_prefix: "source" + + # This job runs our automated test suite, complexity and security baselines + # it ensures previously merged have been tested as part of the pull request process + # + # NOTE + # + # we don't upload the artifact after testing to prevent any tampering of our source code dependencies + quality_check: + needs: seal + runs-on: ubuntu-latest + permissions: + contents: read + steps: + # NOTE: we need actions/checkout to configure git first (pre-commit hooks in make dev) + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + with: + ref: ${{ env.RELEASE_COMMIT }} + + - name: Restore sealed source code + uses: ./.github/actions/seal-restore + with: + integrity_hash: ${{ needs.seal.outputs.integrity_hash }} + artifact_name: ${{ needs.seal.outputs.artifact_name }} + + - name: Debug cache restore + run: cat pyproject.toml + + - name: Install poetry + run: pipx install git+https://github.com/python-poetry/poetry@68b88e5390720a3dd84f02940ec5200bfce39ac6 # v1.5.0 + - name: Set up Python + uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # v5.1.0 + with: + python-version: "3.12" + cache: "poetry" + - name: Install dependencies + run: make dev + - name: Run all tests, linting and baselines + run: make pr + + # This job creates a release artifact (tar.gz, wheel) + # it checks out code from release commit for custom actions to work + # then restores the sealed source code (overwrites any potential tampering) + # it's done separately from release job to enforce least privilege. + # We export just the final build artifact for release + build: + runs-on: ubuntu-latest + needs: [quality_check, seal] + permissions: + contents: read + outputs: + integrity_hash: ${{ steps.seal_build.outputs.integrity_hash }} + artifact_name: ${{ steps.seal_build.outputs.artifact_name }} + attestation_hashes: ${{ steps.encoded_hash.outputs.attestation_hashes }} + steps: + # NOTE: we need actions/checkout to configure git first (pre-commit hooks in make dev) + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + with: + ref: ${{ env.RELEASE_COMMIT }} + + - name: Restore sealed source code + uses: ./.github/actions/seal-restore + with: + integrity_hash: ${{ needs.seal.outputs.integrity_hash }} + artifact_name: ${{ needs.seal.outputs.artifact_name }} + + - name: Install poetry + run: pipx install git+https://github.com/python-poetry/poetry@68b88e5390720a3dd84f02940ec5200bfce39ac6 # v1.5.0 + - name: Set up Python + uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # v5.1.0 + with: + python-version: "3.12" + cache: "poetry" + + - name: Build python package and wheel + run: poetry build + + - name: Seal and upload + id: seal_build + uses: ./.github/actions/seal + with: + artifact_name_prefix: "build" + files: "dist/" + + # NOTE: SLSA retraces our build to its artifact to ensure it wasn't tampered + # coupled with GitHub OIDC, SLSA can then confidently sign it came from this release pipeline+commit+branch+org+repo+actor+integrity hash + - name: Create attestation encoded hash for provenance + id: encoded_hash + working-directory: dist + run: echo "attestation_hashes=$(sha256sum ./* | base64 -w0)" >> "$GITHUB_OUTPUT" + + # This job creates a provenance file that describes how our release was built (all steps) + # after it verifies our build is reproducible within the same pipeline + # it confirms that its own software and the CI build haven't been tampered with (Trust but verify) + # lastly, it creates and sign an attestation (multiple.intoto.jsonl) that confirms + # this build artifact came from this GitHub org, branch, actor, commit ID, inputs that triggered this pipeline, and matches its integrity hash + # NOTE: supply chain threats review (we protect against all of them now): https://slsa.dev/spec/v1.0/threats-overview + provenance: + needs: [seal, build] + permissions: + contents: write # nested job explicitly require despite upload assets being set to false + actions: read # To read the workflow path. + id-token: write # To sign the provenance. + # NOTE: provenance fails if we use action pinning... it's a Github limitation + # because SLSA needs to trace & attest it came from a given branch; pinning doesn't expose that information + # https://github.com/slsa-framework/slsa-github-generator/blob/main/internal/builders/generic/README.md#referencing-the-slsa-generator + uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v2.0.0 + with: + base64-subjects: ${{ needs.build.outputs.attestation_hashes }} + upload-assets: false # we upload its attestation in create_tag job, otherwise it creates a new release + + # This job uses release artifact to publish to PyPi + # it exchanges JWT tokens with GitHub to obtain PyPi credentials + # since it's already registered as a Trusted Publisher. + # It uses the sealed build artifact (.whl, .tar.gz) to release it + release: + needs: [build, seal, provenance] + environment: release + runs-on: ubuntu-latest + permissions: + id-token: write # OIDC for PyPi Trusted Publisher feature + env: + RELEASE_VERSION: ${{ needs.seal.outputs.RELEASE_VERSION }} + steps: + # NOTE: we need actions/checkout in order to use our local actions (e.g., ./.github/actions) + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + with: + ref: ${{ env.RELEASE_COMMIT }} + + - name: Restore sealed source code + uses: ./.github/actions/seal-restore + with: + integrity_hash: ${{ needs.build.outputs.integrity_hash }} + artifact_name: ${{ needs.build.outputs.artifact_name }} + + - name: Upload to PyPi prod + if: ${{ !inputs.skip_pypi }} + uses: pypa/gh-action-pypi-publish@81e9d935c883d0b210363ab89cf05f3894778450 # v1.8.14 + + # Creates a PR with the latest version we've just released + # since our trunk is protected against any direct pushes from automation + bump_version: + needs: [release, seal, provenance] + permissions: + contents: write # create-pr action creates a temporary branch + pull-requests: write # create-pr action creates a PR using the temporary branch + runs-on: ubuntu-latest + steps: + # NOTE: we need actions/checkout to authenticate and configure git first + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + with: + ref: ${{ env.RELEASE_COMMIT }} + + - name: Restore sealed source code + uses: ./.github/actions/seal-restore + with: + integrity_hash: ${{ needs.seal.outputs.integrity_hash }} + artifact_name: ${{ needs.seal.outputs.artifact_name }} + + - name: Download provenance + uses: actions/download-artifact@65a9edc5881444af0b9093a5e628f2fe47ea3b2e # v4.1.7 + with: + name: ${{needs.provenance.outputs.provenance-name}} + + - name: Update provenance + run: mkdir -p "${PROVENANCE_DIR}" && mv "${PROVENANCE_FILE}" "${PROVENANCE_DIR}/" + env: + PROVENANCE_FILE: ${{ needs.provenance.outputs.provenance-name }} + PROVENANCE_DIR: provenance/${{ needs.seal.outputs.RELEASE_VERSION}} + + - name: Create PR + id: create-pr + uses: ./.github/actions/create-pr + with: + files: "pyproject.toml aws_lambda_powertools/shared/version.py provenance/" + temp_branch_prefix: "ci-bump" + pull_request_title: "chore(ci): new pre-release ${{ needs.seal.outputs.RELEASE_VERSION }}" + github_token: ${{ secrets.GITHUB_TOKEN }} diff --git a/aws_lambda_powertools/shared/version.py b/aws_lambda_powertools/shared/version.py index 1f466dc805c..24f86ee3474 100644 --- a/aws_lambda_powertools/shared/version.py +++ b/aws_lambda_powertools/shared/version.py @@ -1,3 +1,3 @@ """Exposes version constant to avoid circular dependencies.""" -VERSION = "2.39.1" +VERSION = "2.39.2a0" diff --git a/provenance/2.39.2a0/multiple.intoto.jsonl b/provenance/2.39.2a0/multiple.intoto.jsonl new file mode 100644 index 00000000000..7ad0a6104d1 --- /dev/null +++ b/provenance/2.39.2a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.39.2a0-py3-none-any.whl","digest":{"sha256":"0016284c2f414f5c658809ae350bb44dc6fae176b863087504f83b49ca44e751"}},{"name":"./aws_lambda_powertools-2.39.2a0.tar.gz","digest":{"sha256":"6695b3ab26825ea4cbaf5118ee90879955ed49765271160bd14ba3aaa336c41a"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/heitorlessa/aws-lambda-powertools-python@refs/heads/develop","digest":{"sha1":"0be52bbab7217e4b9d03ae4838fcb7c8d0a0b998"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{"event_inputs":{"skip_code_quality":"false","skip_pypi":"true"}},"environment":{"github_actor":"heitorlessa","github_actor_id":"3340292","github_base_ref":"","github_event_name":"workflow_dispatch","github_event_payload":{"inputs":{"skip_code_quality":"false","skip_pypi":"true"},"ref":"refs/heads/develop","repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/assignees{/user}","blobs_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/branches{/branch}","clone_url":"https://github.com/heitorlessa/aws-lambda-powertools-python.git","collaborators_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/comments{/number}","commits_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/commits{/sha}","compare_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/contents/{+path}","contributors_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/contributors","created_at":"2020-05-27T08:46:09Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/deployments","description":"A suite of utilities for AWS Lambda Functions that makes tracing with AWS X-Ray, structured logging and creating custom metrics asynchronously easier","disabled":false,"downloads_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/downloads","events_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/events","fork":true,"forks":0,"forks_count":0,"forks_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/forks","full_name":"heitorlessa/aws-lambda-powertools-python","git_commits_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/git/tags{/sha}","git_url":"git://github.com/heitorlessa/aws-lambda-powertools-python.git","has_discussions":false,"has_downloads":true,"has_issues":false,"has_pages":true,"has_projects":true,"has_wiki":false,"homepage":"https://awslabs.github.io/aws-lambda-powertools-python/","hooks_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/hooks","html_url":"https://github.com/heitorlessa/aws-lambda-powertools-python","id":267267667,"is_template":false,"issue_comment_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/issues/events{/number}","issues_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/issues{/number}","keys_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/keys{/key_id}","labels_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/merges","milestones_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/milestones{/number}","mirror_url":null,"name":"aws-lambda-powertools-python","node_id":"MDEwOlJlcG9zaXRvcnkyNjcyNjc2Njc=","notifications_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/notifications{?since,all,participating}","open_issues":16,"open_issues_count":16,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/3340292?v=4","events_url":"https://api.github.com/users/heitorlessa/events{/privacy}","followers_url":"https://api.github.com/users/heitorlessa/followers","following_url":"https://api.github.com/users/heitorlessa/following{/other_user}","gists_url":"https://api.github.com/users/heitorlessa/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/heitorlessa","id":3340292,"login":"heitorlessa","node_id":"MDQ6VXNlcjMzNDAyOTI=","organizations_url":"https://api.github.com/users/heitorlessa/orgs","received_events_url":"https://api.github.com/users/heitorlessa/received_events","repos_url":"https://api.github.com/users/heitorlessa/repos","site_admin":false,"starred_url":"https://api.github.com/users/heitorlessa/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/heitorlessa/subscriptions","type":"User","url":"https://api.github.com/users/heitorlessa"},"private":false,"pulls_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/pulls{/number}","pushed_at":"2024-06-17T12:25:52Z","releases_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/releases{/id}","size":54871,"ssh_url":"git@github.com:heitorlessa/aws-lambda-powertools-python.git","stargazers_count":2,"stargazers_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/stargazers","statuses_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/subscribers","subscription_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/subscription","svn_url":"https://github.com/heitorlessa/aws-lambda-powertools-python","tags_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/tags","teams_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/teams","topics":[],"trees_url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python/git/trees{/sha}","updated_at":"2024-06-17T12:25:55Z","url":"https://api.github.com/repos/heitorlessa/aws-lambda-powertools-python","visibility":"public","watchers":2,"watchers_count":2,"web_commit_signoff_required":false},"sender":{"avatar_url":"https://avatars.githubusercontent.com/u/3340292?v=4","events_url":"https://api.github.com/users/heitorlessa/events{/privacy}","followers_url":"https://api.github.com/users/heitorlessa/followers","following_url":"https://api.github.com/users/heitorlessa/following{/other_user}","gists_url":"https://api.github.com/users/heitorlessa/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/heitorlessa","id":3340292,"login":"heitorlessa","node_id":"MDQ6VXNlcjMzNDAyOTI=","organizations_url":"https://api.github.com/users/heitorlessa/orgs","received_events_url":"https://api.github.com/users/heitorlessa/received_events","repos_url":"https://api.github.com/users/heitorlessa/repos","site_admin":false,"starred_url":"https://api.github.com/users/heitorlessa/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/heitorlessa/subscriptions","type":"User","url":"https://api.github.com/users/heitorlessa"},"workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"267267667","github_repository_owner":"heitorlessa","github_repository_owner_id":"3340292","github_run_attempt":"1","github_run_id":"9547633628","github_run_number":"8","github_sha1":"0be52bbab7217e4b9d03ae4838fcb7c8d0a0b998"}},"metadata":{"buildInvocationID":"9547633628-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/heitorlessa/aws-lambda-powertools-python@refs/heads/develop","digest":{"sha1":"0be52bbab7217e4b9d03ae4838fcb7c8d0a0b998"}}]}}","signatures":[{"keyid":"","sig":"MEUCIA7/5WWCr1qEbJafRiT+BxI9SKZlF/Aqaecvj/iry1c9AiEA1Lp2G2DarxSCMVDPnzt/b3msrfbxA7LB3IpCdc3G5WU=","cert":"-----BEGIN CERTIFICATE-----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\n96G/uGLaqdmu7h+T3L2QePQOe980knox8dgK3vd9el9Onu8p2ZhSbdie\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 35c0bd4808a..e7b39674b24 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "aws_lambda_powertools" -version = "2.39.1" +version = "2.39.2a0" description = "Powertools for AWS Lambda (Python) is a developer toolkit to implement Serverless best practices and increase developer velocity." authors = ["Amazon Web Services"] include = ["aws_lambda_powertools/py.typed", "THIRD-PARTY-LICENSES"]