From 40e92493f03bccbd12f322c81bdca9ff061d8159 Mon Sep 17 00:00:00 2001 From: Mathieu Benoit Date: Wed, 4 Nov 2026 17:39:55 -0500 Subject: [PATCH 1/4] Celebrate 2 years of Score as CNCF Sandbox project This blog post celebrates Score's second anniversary as a CNCF Sandbox project, highlighting achievements, community contributions, and upcoming events. Signed-off-by: Mathieu Benoit --- .../index.md | 83 +++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 content/blog/celebrating-2-year-as-cncf-sandbox/index.md diff --git a/content/blog/celebrating-2-year-as-cncf-sandbox/index.md b/content/blog/celebrating-2-year-as-cncf-sandbox/index.md new file mode 100644 index 0000000..e7e21b4 --- /dev/null +++ b/content/blog/celebrating-2-year-as-cncf-sandbox/index.md @@ -0,0 +1,83 @@ +--- +title: "Celebrating 2 years as CNCF Sandbox" +date: 2026-07-08T00:00:00-00:00 +draft: false +description: "Score turned 2 as a CNCF Sandbox project: a stronger security posture, more adoption, a new hands-on Labspace and two more KubeCons. Next stop: Salt Lake City!" +image: celebrating-2-years-as-cncf-sandbox.jpg +author: mathieu-benoit +--- + +๐ŸŽ‰ Score just turned 2 as a [CNCF Sandbox](https://www.cncf.io/projects/score/) project! ๐ŸŽ‰ + +Two years ago, [Score joined the CNCF](https://score.dev/blog/score-joins-the-cncf-as-a-sandbox-project/). Last year, we [celebrated our first anniversary](https://score.dev/blog/celebrating-1-year-as-cncf-sandbox/) and the 19 new contributors who had joined us. Time still flies, and this second year was packed with great moments, with the same takeaway: Score only goes as far as its community takes it. Thank you to every contributor, user, speaker and maintainer who helped along the way. ๐Ÿ’™ + +Our mission hasn't changed: + +> Score is loved by developers because they can run the same workload on completely different technology stacks, without needing to be an expert in any one of them. + +Here is a look back at what we accomplished over the last 12 months. + +## ๐Ÿš€ More adoption, in the real world + +The best sign that Score's mission resonates is seeing others build on it. + +**Engine** shared how their Infrastructure team uses Score as the service specification layer of a production Kubernetes platform: a single `score.yaml` per service, about 13 custom provisioners, `score-k8s` running inside an ArgoCD plugin, and 25+ Kubernetes resources generated from a file the developer barely has to think about. What used to take days now takes minutes. They also hit a limitation, and instead of working around it they contributed the fix upstream ([score-k8s#232](https://github.com/score-spec/score-k8s/pull/232)), which is a perfect illustration of what we love about open source. Read the full story: [How Engine Built a Self-Service Kubernetes Platform with Score](https://score.dev/blog/engine-self-service-kubernetes-platform-with-score/). + +**KodeKloud** took Score to **KubeCon India 2026** with the talk "The Death of the YAML-Engineer". [Mumshad Mannambeth and Abhinav Sharma](https://score.dev/blog/score-at-kubecon-india-2026/) showed how Score's provisioners can generate Crossplane resources, so that developers get a database by writing a 20-line `score.yaml` and zero infrastructure YAML. A pipeline runs once, a control plane runs forever! They even published the demo as a hands-on lab, so you can replay it yourself. + +And Score keeps showing up next to other CNCF projects, which is one of the things we enjoy the most: +- **Microcks**: Score and Microcks to unify the inner and outer loops, with a [talk at KubeCon EU](https://score.dev/blog/score-at-kubecon-eu-2026-in-amsterdam/). +- **Radius**: the new experimental [`score-radius`](https://github.com/score-spec/score-radius) implementation, demoed during a Radius community meeting. +- **OpenChoreo**: a conversation, and an experimental implementation, are on the way. +- **Docker Model Runner**: `score-compose` now natively supports it, to deploy workloads with local LLM models. + +## ๐Ÿ”’ A stronger security posture + +As a CNCF project, we want to demonstrate security best practices by default. Thanks to the [CNCF and Docker partnership](https://www.cncf.io/announcements/2025/09/18/cncf-expands-infrastructure-support-for-project-maintainers-through-partnership-with-docker/), Score was onboarded into the [Docker-Sponsored Open Source Program](https://score.dev/blog/docker-sponsored-open-source-program/), and the results speak for themselves: +- **Docker Scout** on every pull request and in our registry, with CVE, package and policy comparisons between `main` and each PR. +- **Docker Hardened Images** as base images for our containers: minimal, non-root, with SBOMs and SLSA provenance, and a very smooth migration. +- **`docker/github-builder`** to build our container images, with signed SLSA provenance. +- **OIDC connections** for Docker Hub, replacing long-lived tokens with short-lived ones. +- Our container images now live on [Docker Hub](https://hub.docker.com/u/scorespec), with insights on how they are actually used. + +The full journey, with before/after snippets you can reuse in your own projects, is in the [dedicated blog post](https://score.dev/blog/docker-sponsored-open-source-program/). + +## ๐Ÿงช Learn Score hands-on with the Labspace + +"I get the idea behind Score, but I'd like to try it before setting everything up." We heard that feedback many times, so we released the [**Score Labspace**](https://score.dev/blog/score-labspace/) just a few days ago: a guided lab where the instructions and a ready-to-use terminal live side by side, with all the tools already installed. All you need is Docker: + +{{< highlight shell >}} +docker compose -f oci://scorespec/score-labspace:latest up +{{}} + +In seven short modules, you write one `score.yaml` and deploy it **twice**, with `score-compose` and `score-k8s`, without changing a single line. Then you go further with patch templates and provisioners. It's open source and open to contributions at [score-spec/score-labspace](https://github.com/score-spec/score-labspace). + +## ๐ŸŽค Two more KubeCons + +Since our last anniversary, we have been at two more KubeCons as a CNCF Sandbox project: +- [**KubeCon NA 2025 in Atlanta**](https://score.dev/blog/score-at-kubecon-na-2025-in-atlanta/): a talk about Score and Kro at Cloud Native Rejekts, the Maintainer Summit and our Project Pavilion kiosk. +- [**KubeCon EU 2026 in Amsterdam**](https://score.dev/blog/score-at-kubecon-eu-2026-in-amsterdam/): the Maintainer Summit, the Score + Microcks talk, our kiosk and an update from TAG DevEx. + +Each of these was a great opportunity to meet users, answer questions and hear what you would like to see next. Many of the ideas in this post started as a conversation in front of the kiosk. + +## ๐Ÿ“ Next stop: KubeCon NA in Salt Lake City + +We are going back to where it all started: our first KubeCon as a CNCF Sandbox project was [in Salt Lake City in 2024](https://score.dev/blog/score-at-kubecon-na-in-slc/), and **next week** we are back there for [KubeCon + CloudNativeCon North America 2026](https://events.linuxfoundation.org/kubecon-cloudnativecon-north-america/) (November 9-12) for our fifth! + +Come and meet the Score Maintainers at our kiosk, we will demo the new Labspace live: +- ๐Ÿ“ **Where:** Kiosk **P-17B**, Project Pavilion, Hall 5 (Cosmic Canyon), Level 1, Salt Palace Convention Center +- ๐Ÿ•’ **When:** Thursday, November 12, 10:15 AM - 2:00 PM + +Bring your questions, run the lab with us and tell us what you would like to see in Score's third year. + +## Upwards + +On behalf of the Score Maintainers and the entire Score community, thank you for an amazing second year. Whether you opened an issue, sent a pull request, wrote a blog post, gave a talk or simply gave Score a try, you shaped what it is today. + +Can't wait to see what the community will bring to the Score project in year 3! + +- [Join the #score channel in the CNCF Slack](https://cloud-native.slack.com/archives/C07DN0D1UCW) +- [Get started with Score](https://docs.score.dev/docs/get-started/) or [try the Labspace](https://github.com/score-spec/score-labspace) +- [Contribute to Score](https://clotributor.dev/search?foundation=cncf&project=score) + +See you in Salt Lake City! Let's Score it! ๐ŸŽถ From cbf31b9f1f5db2c00d736047fb7667cb9e83fd19 Mon Sep 17 00:00:00 2001 From: Mathieu Benoit Date: Wed, 4 Nov 2026 19:12:43 -0500 Subject: [PATCH 2/4] Update blog for Score's 2nd anniversary as CNCF Sandbox Updated the blog post to reflect the 2-year anniversary of Score as a CNCF Sandbox project, including changes to the date, content updates, and new community contributions. Signed-off-by: Mathieu Benoit --- .../index.md | 59 +++++++++++++++++-- 1 file changed, 55 insertions(+), 4 deletions(-) diff --git a/content/blog/celebrating-2-year-as-cncf-sandbox/index.md b/content/blog/celebrating-2-year-as-cncf-sandbox/index.md index e7e21b4..c786b8a 100644 --- a/content/blog/celebrating-2-year-as-cncf-sandbox/index.md +++ b/content/blog/celebrating-2-year-as-cncf-sandbox/index.md @@ -1,15 +1,15 @@ --- title: "Celebrating 2 years as CNCF Sandbox" -date: 2026-07-08T00:00:00-00:00 +date: 2026-11-04T00:00:00-00:00 draft: false description: "Score turned 2 as a CNCF Sandbox project: a stronger security posture, more adoption, a new hands-on Labspace and two more KubeCons. Next stop: Salt Lake City!" image: celebrating-2-years-as-cncf-sandbox.jpg author: mathieu-benoit --- -๐ŸŽ‰ Score just turned 2 as a [CNCF Sandbox](https://www.cncf.io/projects/score/) project! ๐ŸŽ‰ +๐ŸŽ‰ Score turned 2 as a [CNCF Sandbox](https://www.cncf.io/projects/score/) project this past July! ๐ŸŽ‰ -Two years ago, [Score joined the CNCF](https://score.dev/blog/score-joins-the-cncf-as-a-sandbox-project/). Last year, we [celebrated our first anniversary](https://score.dev/blog/celebrating-1-year-as-cncf-sandbox/) and the 19 new contributors who had joined us. Time still flies, and this second year was packed with great moments, with the same takeaway: Score only goes as far as its community takes it. Thank you to every contributor, user, speaker and maintainer who helped along the way. ๐Ÿ’™ +On July, 2024, [Score joined the CNCF](https://score.dev/blog/score-joins-the-cncf-as-a-sandbox-project/) and last year, we [celebrated our first anniversary](https://score.dev/blog/celebrating-1-year-as-cncf-sandbox/). Time still flies, and this second year was packed with great moments, with the same takeaway: Score only goes as far as its community takes it. Thank you to every contributor, user, speaker and maintainer who helped along the way. ๐Ÿ’™ Our mission hasn't changed: @@ -31,6 +31,57 @@ And Score keeps showing up next to other CNCF projects, which is one of the thin - **OpenChoreo**: a conversation, and an experimental implementation, are on the way. - **Docker Model Runner**: `score-compose` now natively supports it, to deploy workloads with local LLM models. +## ๐Ÿค Community spotlight: ordered container start + +If one feature illustrates what this community can do together, it's **ordered container start**: the new `before` property in the Score Specification. + +Many workloads need some setup before the main container can run: a schema migration to complete, static data to generate, a shared state to initialize. This is the well-known "init container" and "sidecar" pattern, and until now there was no platform-agnostic way to express it in a Score file. Now there is: + +{{< highlight yaml >}} +apiVersion: score.dev/v1b1 +metadata: + name: myapp +containers: + db-migrate: + image: migrate/migrate:v4 + command: ["up"] + before: + main: + ready: complete + main: + image: myapp:latest +{{}} + +The `db-migrate` container runs _before_ `main`, and `ready` defines when `main` can start: `started` (the default), `complete` or `healthy`. Each Score implementation then maps this to what its platform natively provides: + +| `ready` | `score-compose` (Docker Compose) | `score-k8s` (Kubernetes) | +|---|---|---| +| `started` | `depends_on` with `service_started` | sidecar `initContainers` entry (`restartPolicy: Always`) | +| `complete` | `depends_on` with `service_completed_successfully` | regular `initContainers` entry | +| `healthy` | `depends_on` with `service_healthy` (with a warning if no probe is defined) | rejected with a validation error, since init containers can't be gated on health | + +Both implementations also validate the workload at generation time, to catch containers referencing themselves, unknown containers and cyclic dependencies. + +What makes this feature special is that **it took the whole community to ship it**: + +- [**Chris**](https://github.com/chris-stephenson), one of the Score Maintainers, [proposed the idea](https://github.com/score-spec/spec/issues/104) back in September 2024. He also reviewed the pull requests, including the feedback that led to a simpler design. +- [**kai-kystverket**](https://github.com/kai-kystverket) took the idea and implemented it in the Score Specification: [spec#136](https://github.com/score-spec/spec/pull/136). +- [**Mathieu**](https://github.com/mathieu-benoit) laid the foundation in the shared Go library with [score-go#121](https://github.com/score-spec/score-go/pull/121), so that the implementations could start building on it before the Specification was even released. +- [**Abhishek**](https://github.com/Abhishek9639) did the heavy lifting afterwards: he [refactored the `before` field from an array to a per-container mapping](https://github.com/score-spec/spec/pull/186) (and fixed the schema validation that wasn't kicking in), integrated it in [score-go#178](https://github.com/score-spec/score-go/pull/178), and then implemented the feature in both [`score-compose`](https://github.com/score-spec/score-compose/pull/454) and [`score-k8s`](https://github.com/score-spec/score-k8s/pull/294). +- [**Matthieu**](https://github.com/lekaf974) spotted that the generated types in `score-go` were broken and fixed the `ContainerBefore` structure and the `ready` conditions with [score-go#222](https://github.com/score-spec/score-go/pull/222). + +Five contributors, four Score repositories and about two years from the initial idea to the implementation in both Docker Compose and Kubernetes: that's open source at its best. + +### And it goes beyond Score + +The story doesn't stop there. In mid-2026, Docker Compose [shipped native init containers](https://github.com/docker/compose/pull/13862) with the new `pre_start` service lifecycle hook (Docker Compose v5.3.0). Until then, `score-compose` was emulating init containers with dedicated Compose services and `depends_on`. Abhishek opened [a feature request](https://github.com/score-spec/score-compose/issues/522) to leverage this native primitive, with a detailed analysis of which Score init containers could be converted, and which ones couldn't, and why. + +That's where it gets interesting: the conversation happened openly with [Guillaume Lours](https://github.com/glours), Docker Compose maintainer. Two of the limitations identified by the Score contributors were already lifted on the Compose side, and the others were clarified: some are even by design. Support for the full container specification in hooks then followed in `compose-go` v2.16, which `score-compose` has since adopted. + +This is a great illustration of how Score contributors interact with and influence the OSS projects Score builds on. The work is still in progress (the design of how users opt in to the native output is still being discussed), and everyone is welcome to join the conversation in [score-compose#522](https://github.com/score-spec/score-compose/issues/522). + +Huge kudos to all of you! ๐Ÿ™Œ + ## ๐Ÿ”’ A stronger security posture As a CNCF project, we want to demonstrate security best practices by default. Thanks to the [CNCF and Docker partnership](https://www.cncf.io/announcements/2025/09/18/cncf-expands-infrastructure-support-for-project-maintainers-through-partnership-with-docker/), Score was onboarded into the [Docker-Sponsored Open Source Program](https://score.dev/blog/docker-sponsored-open-source-program/), and the results speak for themselves: @@ -44,7 +95,7 @@ The full journey, with before/after snippets you can reuse in your own projects, ## ๐Ÿงช Learn Score hands-on with the Labspace -"I get the idea behind Score, but I'd like to try it before setting everything up." We heard that feedback many times, so we released the [**Score Labspace**](https://score.dev/blog/score-labspace/) just a few days ago: a guided lab where the instructions and a ready-to-use terminal live side by side, with all the tools already installed. All you need is Docker: +"I get the idea behind Score, but I'd like to try it before setting everything up." We heard that feedback many times, so we recently released the [**Score Labspace**](https://score.dev/blog/score-labspace/): a guided lab where the instructions and a ready-to-use terminal live side by side, with all the tools already installed. All you need is Docker: {{< highlight shell >}} docker compose -f oci://scorespec/score-labspace:latest up From 2a0353707f28d88cea47e395a07cd106d80d3e8a Mon Sep 17 00:00:00 2001 From: Mathieu Benoit Date: Wed, 4 Nov 2026 19:26:53 -0500 Subject: [PATCH 3/4] Enhance discussion on Docker Compose and Score contributions Revised the section discussing Docker Compose's native init containers and the contributions of Score contributors, emphasizing their influence on the OSS project. Signed-off-by: Mathieu Benoit --- content/blog/celebrating-2-year-as-cncf-sandbox/index.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/content/blog/celebrating-2-year-as-cncf-sandbox/index.md b/content/blog/celebrating-2-year-as-cncf-sandbox/index.md index c786b8a..dac2cfb 100644 --- a/content/blog/celebrating-2-year-as-cncf-sandbox/index.md +++ b/content/blog/celebrating-2-year-as-cncf-sandbox/index.md @@ -74,11 +74,7 @@ Five contributors, four Score repositories and about two years from the initial ### And it goes beyond Score -The story doesn't stop there. In mid-2026, Docker Compose [shipped native init containers](https://github.com/docker/compose/pull/13862) with the new `pre_start` service lifecycle hook (Docker Compose v5.3.0). Until then, `score-compose` was emulating init containers with dedicated Compose services and `depends_on`. Abhishek opened [a feature request](https://github.com/score-spec/score-compose/issues/522) to leverage this native primitive, with a detailed analysis of which Score init containers could be converted, and which ones couldn't, and why. - -That's where it gets interesting: the conversation happened openly with [Guillaume Lours](https://github.com/glours), Docker Compose maintainer. Two of the limitations identified by the Score contributors were already lifted on the Compose side, and the others were clarified: some are even by design. Support for the full container specification in hooks then followed in `compose-go` v2.16, which `score-compose` has since adopted. - -This is a great illustration of how Score contributors interact with and influence the OSS projects Score builds on. The work is still in progress (the design of how users opt in to the native output is still being discussed), and everyone is welcome to join the conversation in [score-compose#522](https://github.com/score-spec/score-compose/issues/522). +The story doesn't stop there. When Docker Compose [shipped native init containers](https://github.com/docker/compose/pull/13862) with `pre_start`, [**Abhishek**](https://github.com/Abhishek9639) opened [a feature request](https://github.com/score-spec/score-compose/issues/522) for `score-compose` to leverage it, with a detailed analysis of which Score init containers could be converted. The feedback shared with Docker Compose maintainer [Guillaume Lours](https://github.com/glours) directly influenced the Compose implementation itself: the limitations Score contributors identified, such as hooks not being able to set their own `command` or volumes, were addressed on the Compose side, with hooks now supporting the full container specification. A great example of Score contributors not only building on top of OSS projects, but also helping shape them. The work is still in progress, and you're welcome to join the conversation! Huge kudos to all of you! ๐Ÿ™Œ From 9c8992cf6e1164b5c5695aced9c39a56c14560e9 Mon Sep 17 00:00:00 2001 From: Mathieu Benoit Date: Thu, 5 Nov 2026 19:28:04 -0500 Subject: [PATCH 4/4] Update content/blog/celebrating-2-year-as-cncf-sandbox/index.md Co-authored-by: Chris <52924685+chris-stephenson@users.noreply.github.com> Signed-off-by: Mathieu Benoit Signed-off-by: Mathieu Benoit --- content/blog/celebrating-2-year-as-cncf-sandbox/index.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/content/blog/celebrating-2-year-as-cncf-sandbox/index.md b/content/blog/celebrating-2-year-as-cncf-sandbox/index.md index dac2cfb..91c5d39 100644 --- a/content/blog/celebrating-2-year-as-cncf-sandbox/index.md +++ b/content/blog/celebrating-2-year-as-cncf-sandbox/index.md @@ -78,6 +78,10 @@ The story doesn't stop there. When Docker Compose [shipped native init container Huge kudos to all of you! ๐Ÿ™Œ +## ๐Ÿ”ฎ The path to V1 + +As we hit 2 years as a Sandbox project, it's really about time we got to `v1` of the spec (yes, we're still on `v1b1`!) [**Chris**](https://github.com/chris-stephenson) has been gathering requirements since the start of the year for our discussion of what a `v1` of the spec would look like. You can still contribute your ideas in the community Doc [here](https://docs.google.com/document/d/19qkncxA2pduyAwgjfAl-lQs4hEhjhAm0yrXxy-5u8dg/edit). The biggest thing is to make Score compatible with the Kubernetes Custom Resource schema, opening up interesting use-cases of "Score Operators". We also heard the feedback from the community that out "implementation" approach is not very reusable, so we're rebuilding the score-go library to allow for better code-reuse and importing your favourite score implementations as packages in Go! + ## ๐Ÿ”’ A stronger security posture As a CNCF project, we want to demonstrate security best practices by default. Thanks to the [CNCF and Docker partnership](https://www.cncf.io/announcements/2025/09/18/cncf-expands-infrastructure-support-for-project-maintainers-through-partnership-with-docker/), Score was onboarded into the [Docker-Sponsored Open Source Program](https://score.dev/blog/docker-sponsored-open-source-program/), and the results speak for themselves: