<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Jenkins X - Medium]]></title>
        <description><![CDATA[Accelerate Your Continuous Delivery on Kubernetes - Medium]]></description>
        <link>https://medium.com/jenkins-x?source=rss----b729485cb647---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Jenkins X - Medium</title>
            <link>https://medium.com/jenkins-x?source=rss----b729485cb647---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:40:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/jenkins-x" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Designing Cloud-Native CI/CD Pipelines with Jenkins X]]></title>
            <link>https://medium.com/jenkins-x/designing-cloud-native-ci-cd-pipelines-with-jenkins-x-473d511144fa?source=rss----b729485cb647---4</link>
            <guid isPermaLink="false">https://medium.com/p/473d511144fa</guid>
            <category><![CDATA[jenkins-x]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Vincent Behar]]></dc:creator>
            <pubDate>Wed, 08 Apr 2020 10:56:40 GMT</pubDate>
            <atom:updated>2020-06-15T09:41:37.217Z</atom:updated>
            <content:encoded><![CDATA[<h4>Design and implementation of Cloud-Native CI/CD Pipelines on Kubernetes for the enterprise, using Jenkins X.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CTx_e6o_G6vELl8zGwVQWg.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@victor_g?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Victor Garcia</a> on <a href="https://unsplash.com/s/photos/pipelines?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>The cloud-native era has opened up a whole new level for CI/CD, and it’s impacting the design of our pipelines. The days of the big monolith pipeline that only one person can decipher are gone. Let’s see how we can design and implement cloud-native CI/CD pipelines on Kubernetes, for the enterprise, using <a href="https://jenkins-x.io/">Jenkins X</a>.</p><h4>Requirements</h4><p>Let’s review our requirements first. I said “<em>for the enterprise</em>”, because writing pipelines for a single open-source project or hundreds/thousands of enterprise projects is not the same.</p><p>The first requirement is the <strong>conventions or standards you might have in your company around code quality, testing, packaging</strong> and so on. You’d like to ensure that developers will get the same experience working across different repositories using different programming languages. The presence of a CI/CD pipeline is usually the one consistent thing you’ll find on all repositories. We just need to ensure that the content of that pipeline will be consistent too.</p><p>The second one is the <strong>DRY principle: Don’t Repeat Yourself</strong>. With dozen, hundreds or even thousands of repositories in your organization, you’d like to avoid copying big monolith pipelines everywhere. Keep the definition of your application’s pipelines as small as possible, using inheritance or shared pipelines when possible.</p><p>The third one is the <strong>maintenance cost</strong>. Updating pipelines across all your repositories is a complex task. A small change might break the pipelines for half of the projects, and you’d like to know it as soon as possible. And even better: don’t break anything. But still, keep all projects — including the half-dormant ones — up to date.</p><p>And the last one is <strong>extensibility</strong>. If you are using inheritance or shared pipelines, you should be able to customize them easily, without rewriting the whole pipeline from scratch.</p><h4>Jenkins X Features</h4><p>Jenkins X has a set of very interesting features, including:</p><ul><li><strong>support for multiple pipelines per repository</strong>. Meaning you can have multiple jenkins-x.yml files in your repository, and all of them will be used to trigger new pipelines. These pipelines will run in parallel and post different “checks” on your GitHub Pull Request.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RhFpSYCKsngDuS14sVNivw.png" /></figure><ul><li><strong>Build Packs and Pipelines inheritance</strong>. One of the <a href="https://jenkins-x.io/docs/reference/components/build-packs/">Build Packs</a> use-cases is to provide pipelines that can be “imported” by other projects. Thus allowing inheritance of pipelines.</li><li><strong>Pipelines override</strong>. Jenkins X Pipelines are written in YAML. Sure, it’s a pain to write verbose YAML, but it also has benefits, including the ability to manipulate the file content programmatically. Pipelines that inherits from a build pack can override part of the parent pipeline: add a custom command, remove another one, replace a third.</li><li><strong>Release promotion</strong>. One of the main practices behind Jenkins X is Gitops. To apply Gitops, Jenkins X “promotes” the application’s releases by creating Pull Request to update versions stored in git repositories. So if we release our build packs, we can use Gitops and release promotion to easily update the versions referenced in all the projects.</li></ul><h4>Jenkins X Pipelines Design</h4><p>Now let’s design our ideal CI/CD Pipelines using Jenkins X.</p><p>We’ll use a single release pipeline, defined in the main jenkins-x.yml file. But we’ll define multiple pipelines for our Pull Requests: unit tests, integration tests, deployment of the preview environment, validation of the Helm Chart, and code lint.</p><p>Splitting our old monolith pipeline in multiple small ones has many benefits:</p><ul><li>pipelines’ definitions are smaller and focused on a single goal.</li><li>it will be easier to use pipelines inheritance with small and focused pipelines.</li><li>pipelines will be executed in parallel, giving faster feedback to the developers.</li><li>failed pipelines can be re-executed in isolation of the others.</li><li>it will help to maintain your conventions and standards across all repositories because all projects will need to think about unit and integration tests, code lint, and so on.</li></ul><p>We’ll create custom build packs with generic pipelines for the release, the preview environment deployment, and the Helm chart validation. We’ll also write generic pipelines for all supported languages for unit tests, integration tests, and lint. These generic pipelines should be easily customizable, with custom environment variables for example.</p><p>For the steps of the pipelines that require a bit of scripting, we’ll write scripts, store them in Git, and make them available to all steps. We don’t want to require developers to store them in all their repositories, nor do we want to package them in all the container images we’ll use in our pipelines. We could apply the pattern used by <a href="https://tekton.dev/">Tekton</a> to access its tools from any container: store them in a shared pod volume at the beginning of the pipeline, and mount that volume in all containers.</p><p>We’ll make sure to define our generic pipelines with all the required context — credentials, environment variables — so that if someone wants to override part of a pipeline by adding a custom step, he doesn’t have to write a lot of glue to retrieve a set of credentials from a Kubernetes secret.</p><p>And we’ll ensure that all our applications use specific versions of our build packs. We’ll release and promote our build packs, to trigger new Pull Requests in all the repositories that use them. This will execute the new version of the pipelines in the context of all the repositories, ensuring nothing is broken before merging to the master branch, and using it for all builds. Of course, this practice works best in a cloud environment with a cluster auto-scaler, because it will run a lot of pipelines in parallel. But even if you don’t have enough resources, pods will just be “queued” and wait for their turn to consume resources.</p><h4>Jenkins X Pipelines Implementation</h4><p>Let’s get into the implementation details now!</p><p>We’ll start by creating a custom <a href="https://jenkins-x.io/docs/reference/components/custom-resources/#scheduler">Jenkins X Scheduler</a> to define our multiple pipelines:</p><pre>apiVersion: jenkins.io/v1<br>kind: Scheduler<br>spec:<br>  presubmits:<br>    entries:<br>      - agent: tekton<br>        alwaysRun: true<br>        context: unit-tests<br>        name: unit-tests<br>        optional: false<br>        rerunCommand: /test unit<br>        trigger: (?m)^/test( all| unit),?(\s+|$)<br>      - agent: tekton<br>        alwaysRun: true<br>        context: integration-tests<br>        name: integration-tests<br>        optional: false<br>        rerunCommand: /test integration<br>        trigger: (?m)^/test( all| integration),?(\s+|$)</pre><p>This is just part of the scheduler’s config. See <a href="https://github.com/jenkins-x/environment-tekton-weasel-dev/blob/master/env/templates/jx-scheduler.yaml">the scheduler config used in Jenkins X</a> for a complete configuration. Don’t forget to link your source repositories to your new scheduler — in the SourceRepository CRD.</p><p>We’ll also need to create a new Git repository for our build packs. See <a href="https://github.com/jenkins-x-buildpacks/jenkins-x-kubernetes">https://github.com/jenkins-x-buildpacks/jenkins-x-kubernetes</a> for an example. Note that the build packs must be in the packs directory of your repository:</p><pre>├── OWNERS<br>├── README.md<br>├── jenkins-x.yml<br>├── packs<br>│   ├── README.md<br>│   ├── go-lint<br>│   │   ├── README.md<br>│   │   └── pipeline.yaml<br>│   ├── go-unit-tests<br>│   │   ├── README.md<br>│   │   └── pipeline.yaml<br>│   ├── helm-chart-validation<br>│   │   ├── README.md<br>│   │   └── pipeline.yaml<br>│   ├── preview-env<br>│   │   ├── README.md<br>│   │   └── pipeline.yaml<br>│   ├── release<br>│   │   ├── README.md<br>│   │   └── pipeline.yaml</pre><p>Our build packs pipelines are written in pipeline.yaml files instead of jenkins-x.yml files:</p><pre>pipelines:<br>  pullRequest:<br>    pipeline:<br>      agent:<br>        image: golang:1.14<br>      options:<br>        containerOptions:<br>          resources:<br>            requests:<br>              cpu: 1<br>              memory: 512Mi<br>      stages:<br>        - name: unit-tests<br>          steps:<br>            - name: go-test<br>              command: GOFLAGS=${GOFLAGS:-$DEFAULT_GOFLAGS} go test<br>              args:<br>                - -v<br>                - ${PACKAGES:-$DEFAULT_PACKAGES}<br>              env:<br>                - name: DEFAULT_GOFLAGS<br>                  value: -mod=vendor<br>                - name: DEFAULT_PACKAGES<br>                  value: ./...</pre><p>Notice how we’re allowing users of our pipeline to customize the GOFLAGS or packages, while still providing good default values.</p><p>A complete jenkins-x-unit-tests.yml file in an application’s repository will look like:</p><pre>buildPack: go-unit-tests<br>buildPackGitURL: <a href="https://github.com/dailymotion/leo-jx-buildpacks.git">https://github.com/owner/jx-buildpacks.git</a><br>buildPackGitRef: 1.2.3</pre><pre>pipelineConfig:<br>  env:<br>    - name: GOFLAGS<br>      value: &quot;-v -timeout=10s&quot;</pre><p>Overriding part of the build pack pipeline:</p><pre>buildPack: go-unit-tests<br>buildPackGitURL: <a href="https://github.com/dailymotion/leo-jx-buildpacks.git">https://github.com/owner/jx-buildpacks.git</a><br>buildPackGitRef: 1.2.3</pre><pre>pipelineConfig:<br>  pipelines:<br>    overrides:<br>      - type: replace<br>        pipeline: pullRequest<br>        stage: unit-tests<br>        name: go-test<br>        steps:<br>          - name: custom-go-test<br>            command: /path/to/some/custom-command<br>            image: my-custom-container-image</pre><p>Some of our build packs pipelines will require scripting. We’ll store our scripts in the scripts directory of our build packs repository:</p><pre>├── OWNERS<br>├── README.md<br>├── jenkins-x.yml<br>├── packs<br>└── scripts<br>    ├── Dockerfile<br>    ├── README.md<br>    ├── some-script.sh<br>    ├── another-script.sh</pre><p>Notice that we have a Dockerfile in this directory. We use it to store all our scripts in a container image:</p><pre>FROM alpine:3.11<br>COPY . /scripts/</pre><p>We’ll then apply the “Tekton shared-scripts pattern” in our pipelines, to copy the scripts from our container image to a shared volume, and mount this volume on all our containers:</p><pre>pipelines:<br>  release:<br>    pipeline:<br>      options:<br>        containerOptions:<br>          volumeMounts:<br>            - mountPath: /my-jx-buildpacks-scripts<br>              name: my-jx-buildpacks-scripts<br>        volumes:<br>          - name: my-jx-buildpacks-scripts<br>            emptyDir: {}<br>      env:<br>        - name: MY_JX_BUILDPACKS_SCRIPTS<br>          value: /my-jx-buildpacks-scripts<br>      stages:<br>        - name: release<br>          steps:<br>            - name: copy-my-jx-buildpacks-scripts<br>              command: cp -r /scripts/* ${MY_JX_BUILDPACKS_SCRIPTS}/<br>              image: my-jx-buildpacks-scripts-image:latest<br>            - name: some-step<br>              command: ${MY_JX_BUILDPACKS_SCRIPTS}/some-script.sh<br>              image: some/image:version</pre><p>The main advantage of this pattern is that we can use our scripts from any steps — including custom ones defined in the application’s pipelines — whatever the container image and the source repository.</p><p>Now we’ll need to release both our build packs and scripts. We can use a jenkins-x.yml file in our build packs repository to define the pipeline that will do that. We’ll need to use a custom setVersion step to ensure our tagged build packs will use the right version of the scripts:</p><pre>buildPack: none<br>pipelineConfig:<br>  pipelines:<br>    release:<br>      setVersion:<br>        steps:<br>          - name: next-version<br>            command: jx step next-version<br>            args:<br>              - --use-git-tag-only<br>          - name: fix-scripts-image-version<br>            command: sed<br>            args:<br>              - -i<br>              - &quot;-e \&quot;s,image: my-jx-buildpacks-scripts-image:latest,image: my-jx-buildpacks-scripts-image:`cat VERSION`,g\&quot;&quot;<br>              - packs/*/pipeline.yaml<br>          - name: git-tag<br>            command: jx step tag</pre><p>This will update our packs/release/pipeline.yaml file and insert the new release version for our scripts container image.</p><p>The rest of the pipeline will be responsible for building the scripts container image with <a href="https://github.com/GoogleContainerTools/kaniko">Kaniko</a> and generating the GitHub release with the <a href="https://jenkins-x.io/commands/jx_step_changelog/">jx step changelog</a> command.</p><p>The next interesting part is the promotion of our new release, to generate Pull Requests to update all the application’s pipelines using one of our build packs. We’re using <a href="https://github.com/dailymotion/octopilot">Octopilot</a> to do it:</p><pre>buildPack: none<br>pipelineConfig:<br>  pipelines:<br>    release:<br>      pipeline:<br>        stages:<br>          - name: promotion<br>            steps:<br>              - name: promote<br>                command: octopilot<br>                args:<br>                  - &gt;-<br>                    --update &quot;regex(file=jenkins-x*.yml,pattern=&#39;buildPackGitURL: <a href="https://github.com/dailymotion/leo-jx-buildpacks.git/s+buildPackGitRef">https://github.com/owner/my-jx-buildpacks.git\s+buildPackGitRef</a>: (.*)&#39;)=${VERSION}&quot;<br>                  - --repo &quot;discover-from(query=org:owner topic:auto-update-my-jx-buildpacks)&quot;<br>                image: dailymotion/octopilot:latest</pre><p>It will first search on GitHub for all repositories in the owner organization with the auto-update-my-jx-buildpacks topic. The matching repositories will then be cloned locally, and Octopilot will update all thejenkins-x*.yml files with content matching the given regex, and then create Pull Requests.</p><p>Using Octopilot to do the promotion of our new releases allows us to scale to hundreds of repositories because when you add a new repository you just need to give it the right label.</p><p>Using Jenkins X practices and features, we’ve been able to design and write modern cloud-native CI/CD pipelines which have a low maintenance cost, are extensible, and help apply our global conventions and standards.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=473d511144fa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/jenkins-x/designing-cloud-native-ci-cd-pipelines-with-jenkins-x-473d511144fa">Designing Cloud-Native CI/CD Pipelines with Jenkins X</a> was originally published in <a href="https://medium.com/jenkins-x">Jenkins X</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes controller for Google Secrets Manager]]></title>
            <link>https://medium.com/jenkins-x/kubernetes-controller-for-google-secrets-manager-6ecfd40ac11f?source=rss----b729485cb647---4</link>
            <guid isPermaLink="false">https://medium.com/p/6ecfd40ac11f</guid>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[James Rawlings]]></dc:creator>
            <pubDate>Thu, 05 Mar 2020 20:42:41 GMT</pubDate>
            <atom:updated>2020-03-05T20:51:45.077Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zAYxyb8RsOMJReVMOuP4cA.png" /></figure><p>In Jenkins X Labs we have been working with <a href="https://cloud.google.com/secret-manager/docs">Google Secrets Manager</a> (which is currently in Beta so may still change). It is an extremely nice experience and if you also use Google Container Engine (GKE), Google’s managed Kubernetes service then we can make use of another cool feature, <a href="https://cloud.google.com/kubernetes-engine/docs/how-to/workload-identity">Workload Identity</a> to automatically access secrets in their hosted service using a Kubernetes service account.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/140/1*t8v9dPLlG5Vsd8KmxMf8KQ.png" /></figure><p>One of the initial challenges we had was we didn’t see an obvious way to automatically create Kubernetes secrets that include the data stored from Secrets Manager. So we created a little standalone controller that runs in a Kubernetes cluster and watches for Kubernetes secrets. When one is added or updated with a particular annotation the controller will access the secret using its ID in Secrets Manager and update the Kubernetes secret with the value.</p><p>Full docs and code can be found here:</p><p><a href="https://github.com/jenkins-x-labs/gsm-controller/blob/master/README.md">https://github.com/jenkins-x-labs/gsm-controller/blob/master/README.md</a></p><h3>TL;DR</h3><p>Create an empty secret</p><pre>kubectl create secret generic my-secret</pre><p>Add the magic annotation that the controller uses to lookup the correct secret in Googles Secret Manager</p><pre>kubectl annotate secret my-secret jenkins-x.io/gsm-secret-id=foo</pre><p>Optionally if you want the Kubernetes secret to use a specific key for the data you can add another annotation</p><pre>kubectl annotate secret my-secret jenkins-x.io/gsm-kubernetes-secret-key=credentials.json</pre><h3>Demo</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FwLHgkhzeNe8%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DwLHgkhzeNe8&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FwLHgkhzeNe8%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/cdab7c9e41f29bb390092f6e753db093/href">https://medium.com/media/cdab7c9e41f29bb390092f6e753db093/href</a></iframe><p>This is still early days and we’d love folks to try it and provide feedback ( <a href="https://jenkins-x.io/community/#slack">slack</a> or the new <a href="https://github.com/jenkins-x-labs/issues/issues">labs issues</a>) on whether it is useful to others and how we can improve it together.</p><p>On Jenkins X we make use of Hashicorp’s Vault which is great although it is another service users have to run, manage and upgrade. Wherever possible Jenkins X aims to use the Cloud well, so when users are installing Jenkins X onto a Cloud Provider we would like to leverage their other managed services, reducing the deployments we need to run in users clusters for Jenkins X.</p><p><em>Originally published at </em><a href="https://jenkins-x.io/blog/2020/03/05/gsm-controller/"><em>https://jenkins-x.io</em></a><em> on March 5, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ecfd40ac11f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/jenkins-x/kubernetes-controller-for-google-secrets-manager-6ecfd40ac11f">Kubernetes controller for Google Secrets Manager</a> was originally published in <a href="https://medium.com/jenkins-x">Jenkins X</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jenkins X Labs]]></title>
            <link>https://medium.com/jenkins-x/jenkins-x-labs-20d9b8eb859d?source=rss----b729485cb647---4</link>
            <guid isPermaLink="false">https://medium.com/p/20d9b8eb859d</guid>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[jenkins-x]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[James Rawlings]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 17:14:23 GMT</pubDate>
            <atom:updated>2020-02-28T11:41:12.641Z</atom:updated>
            <content:encoded><![CDATA[<p>Jenkins X Labs February update</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*ZxPJCbaTbBWkz0dm.png" /></figure><p>Jenkins X has entered it’s third year and as always we are looking for big ways things can be improved. Briefly reflecting on the last two years:</p><ul><li>first was about initial adoption and finding out what developers were both looking for and needed when moving to Kubernetes. We started off using a Static Jenkins server for example to orchestrate builds and other open source projects that folks would be familiar with, to aid their journey to the cloud. We quickly realised that the Jenkins X community wanted to leverage more of their cloud capabilities and so we began to swap in cloud native implementations like Tekton and Prow, as well as better integration with managed cloud services like storage, dns, IAM etc.</li><li>second year was about improving that developer experience and making the architectural approaches we settled on a reliable experience. This has been a lot of work and there’s still a lot more to do, in fact we know this will always be an ongoing effort. Some of the recent highlights of this effort can start to be seen with more details on this <a href="https://jenkins-x.io/blog/2020/02/26/cjxd-feb-20/">blog</a></li><li>now that we have started our third year we look at how we can effectively innovate in Jenkins X, grow collaborations with other open source projects and communities and of course build up the Jenkins X community itself. All the time we need to do this with the second years efforts in mind and not lose sight that we need to evolve as a mature project that people and teams can rely on.</li></ul><p>We’ve started by introducing the idea of an enhancement process. The aim here is to raise ideas and larger problems that folks would like to collaborate on earlier than when a Pull Request is created. Sometimes issues are a bit low level and for bigger efforts we’d like to raise the profile, potentially discuss in office hours, getting as much early feedback as possible and hope to attract folks looking to be involved. This is aimed to be a lightweight process and be used to help get things right earlier. It is not meant to stifle progress, rather enhance it. Not all changes to Jenkins X should have an enhancement proposal, we still want to attract contributions but for larger efforts this will hopefully help.</p><p>Enhancement proposals are currently raised as a pull request to this repository <a href="https://github.com/jenkins-x/enhancements">https://github.com/jenkins-x/enhancements</a>. Jenkins X creates a lot of GitHub notifications with all the releases and bot updates but this repo would be useful to ‘watch’ and see new proposals + discussions as they happen. Please if you have any views we’d absolutely love to hear them and every comment will be treated respectfully and in a safe healthy environment. We’ve already had <strong>GREAT</strong> input from <a href="https://github.com/polothy">polothy</a>, <a href="https://github.com/salaboy">salaboy</a> and a bunch of core maintainers as well as PMs and engineering managers. We’d like to encourage involvement from any background that would like to help Jenkins X and be part of something that we can all be proud of.</p><p>The second part of this blog wants to take your attention to an enhancement proposal which is currently up for review <a href="https://github.com/jenkins-x/enhancements/pull/15">https://github.com/jenkins-x/enhancements/pull/15</a>. This aims to tackle the challenge outlined above, of how do we enable rapid innovation, increase contributions and collaborations while keeping Jenkins X stable. Please take a look and feed any comments on, it is high level for a reason as we are still learning the right balance.</p><p>TL;DR of the above proposal suggests we build out an incubation hub of sorts where we can create new features which we don’t know how they might be received, gather feedback and other metrics to decide whether the feature is good to mature into the main Jenkins X org. The idea is to use an approach where features are ready for alpha, beta and GA.</p><p>We have already started piloting this effort in the <a href="https://github.com/jenkins-x-labs">Jenkins X Labs</a> GitHub org where a small team has been proving out a feature to handle Jenkins X deploying to different clusters including different cloud providers. The feature is known as multi cluster but we will be documenting, demoing and asking people to help be involved either in development or trials.</p><p>We will be putting together a roadmap, starting off small but would love suggestions <a href="https://github.com/jenkins-x-labs/issues">https://github.com/jenkins-x-labs/issues</a> It is important to stress that work which happens in the Jenkins X Labs GitHub organisation may or may not mature into the Jenkins X org. We will work hard to prove out any ideas and and gather as much feedback as we can and improve. We would be looking to make it clear users opt into using alpha or beta features so we maintain a solid base.</p><p>We are super excited by this proposal, the rate of innovation it will unlock and the level of OSS collaboration possible all the time having another focus on stability and reliability.</p><p><em>Originally published at </em><a href="https://jenkins-x.io/blog/2020/02/28/jxl-feb-20/"><em>https://jenkins-x.io</em></a><em> on February 28, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20d9b8eb859d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/jenkins-x/jenkins-x-labs-20d9b8eb859d">Jenkins X Labs</a> was originally published in <a href="https://medium.com/jenkins-x">Jenkins X</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>