Category: Jenkins X

  • CloudBees Connect Virtual Summit: Defining the Future of Software Development

    CloudBees Connect Virtual Summit: Defining the Future of Software Development

    CloudBees Connect Virtual Summit will bring together a global community of developers, CloudBees and Jenkins users, DevOps luminaries and continuous delivery experts for two full days of immersive learning, presented in a virtual reality environment. The event is scheduled to take place on May 19 at 11 a.m. EDT for North America, and on May 20 at 11 a.m. CET for the European audience.

    At CloudBees Connect, you will learn about the emerging trends and technologies shaping the future of software, including one of the most innovative trends in technology: continuous delivery. Continuous delivery allows you to deliver software faster and with lower risk, while preserving quality and reliability.

    Industry leaders will share their knowledge and expertise on CI/CD tools and best practices. You will learn how to successfully create a fully operational CD pipeline using containers, Kubernetes and Jenkins X; and how to automate security and privacy testing in your Jenkins CI/CD pipeline for continuous security.

    The event will consist of a series of workshops designed to provide great value to the attendees. Here are a few things you will learn by attending these workshops:

    • How your COBOL source code can be branched/merged/deployed using GitHub, CloudBees and Compuware tooling.
    • Best practices for continuously integrating code using CloudBees Core.
    • How to build and test applications using Jenkins Pipelines and Sauce Labs.
    • Solutions for the five most common Jenkins issues.
    • The role of feature flags in reducing risks associated with deployments.

    The workshops will feature a lineup of DevOps and continuous delivery leaders, including:

    • Oscar Medina, developer advocate at CloudBees
    • Viktor Farcic, Jenkins X product manager, principal software delivery strategist and developer advocate at CloudBees
    • Josh Grant, solution architect at Sauce Labs
    • Robert Kelley, director of delivery engineering at IHG
    • Stuart Ashby, DevOps specialist at Compuware
    • Alex Taylor, DevOps engineer at insightsoftware

    Discover what’s next from the CloudBees and Jenkins community, connect with industry experts and fellow developers, and get the skills and hands-on training you need in order to successfully deliver software.

    To check out the agenda, the full lineup of speakers and to register (for free), visit the CloudBees Connect website.

  • Jenkins X Continues To Experience Strong Demand, Speeding Development Of Cloud Native Applications

    CloudBees introduces first GUI for Jenkins X as downloads, contributors and corporate support to the open source project grow

     

    KUBECON SAN DIEGO, CA. AND SAN JOSE, CA. – November 20, 2019 – CloudBees, the enterprise DevOps leader powering the continuous economy, today introduced a graphical user interface (GUI) for Jenkins X at KubeCon San Diego. CloudBees’ announcement comes at a time when the Jenkins X open source project and CloudBees’ support for the project are both gaining momentum at a rapid rate, with contributors and supporting companies hitting all-time highs.

     

    In less than two years, approximately 885 developers have contributed code to the Jenkins X project and there are 176 contributing companies (Source: Continuous Delivery Foundation DevStats, October 2019).

    Jenkins X offers automated CI/CD for cloud native applications on Kubernetes. Using Jenkins X, developers can leverage Kubernetes to build and deploy cloud native applications quickly and easily without having to learn the intricacies of Kubernetes and its ecosystem. The Jenkins X project, initiated by CloudBees and other contributors in February 2018, is now part of the Continuous Delivery Foundation.

    “As a software developer in charge of migrating monoliths to microservices deployed to Kubernetes, Jenkins X has helped me and my teams to be efficient in managing complex projects that require 100+ source code repositories to be deployed to different Kubernetes clusters,” said Mauricio Salatino, principal software developer for a workflow and decision automation platform company and an instructor at Learnk8s. “This was a task that initially looked impossible for a team of just four people, but we did it easily with Jenkins X.”

    Jenkins X continues to be enhanced at a rapid pace. CloudBees’ introduction of a new GUI in its CloudBees Jenkins X Distribution gives developers more flexibility and a richer user experience. The existing command line interface (CLI) loved by many developers is still available and continues to be enhanced, but now users have a choice to use the CLI or the new graphical environment, depending on which better suits their workflow. The CloudBees Jenkins X Distribution is a free offering from CloudBees.

    “Our goal is to make Jenkins X the most friction-free environment for developers looking to use Kubernetes in an opinionated, automated way,” said Mo Plassnig, vice president of cloud, CloudBees. “Offering a richer, more intuitive GUI is just the start. Contributors throughout CloudBees and the Continuous Delivery Foundation ecosystem are hard at work creating more improvements – everything from log handling to environment promotions to onboarding of workflows.”

    “The numbers show that our vision for Jenkins X was right on target,” said James Strachan, a distinguished engineer at CloudBees and one of the founders of Jenkins X. “As more organizations embrace DevOps, the need for a CI/CD solution that leverages the power of Kubernetes with the rich capabilities and straight-forward convenience of Jenkins X has continued to grow.”

    Additional Resources

    Download Jenkins X

     

    About CloudBees
    CloudBees is powering the continuous economy by offering the world’s first end-to-end continuous software delivery management system (SDM). For millions of developers and product teams driving innovation for businesses large or small, SDM builds on continuous integration (CI) and continuous delivery (CD) to enable all functions and teams within and around the software delivery organization to best work together to amplify value creation.

    CloudBees is the CI, CD and application release orchestration (ARO) powerhouse, built on the commercial success of its products as well as its open source leadership. CloudBees is the largest contributor to Jenkins and Jenkins X, and a founding member of the Continuous Delivery Foundation (CDF). From startups with full-stack developers practicing NoOps to large Fortune 100 companies, CloudBees enables all software-driven organizations to intelligently deploy the right capabilities at the right time.

    Over 3,500 of the world’s best-known brands and over 50% of the Fortune 500, invest in CloudBees because of its ability to work across any cloud, in any development environment and to balance corporate governance and control with developer flexibility and freedom. CloudBees is home to the world’s leading DevOps experts, helping thousands of companies harness the power of “continuous everything” and putting them on the fastest path from great idea, to great software, to great business value.

    Backed by Matrix Partners, Lightspeed Venture Partners, Verizon Ventures, Delta-v Capital, Golub Capital and Unusual Ventures, CloudBees was founded in 2010 by former JBoss CTO Sacha Labourey and an elite team of continuous integration, continuous delivery and DevOps professionals. Follow CloudBees on Twitter, Facebook and LinkedIn.

     

  • Simplified Telephony Solutions

    Simplified Telephony Solutions

    Simplified Telephony Solutions Makes Easy, Quick Move to Jenkins X

    An easy, quick move to Jenkins X saves hours for Simplified Telephony Solutions developers, freeing up their time to focus on code, quality and customers.

     My favorite thing about Jenkins X is it really is a one size fits all solution. From day one, it just worked. Now we have more time to focus on what’s important – our code, our software and our customers. 
    Matthew Lebrasseur
    Vice President of Information Technology

    [su_youtube url=”https://www.youtube.com/watch?v=EUPq3WQ1Y98&feature=youtu.be”]

  • Announcing the CloudBees Jenkins X Distribution

    Announcing the CloudBees Jenkins X Distribution

    Today we are announcing the first release of the CloudBees Jenkins X Distribution. It’s a battle-tested, preconfigured ready-to-go package for Jenkins X that you can count on today. We’ll vouch for it with support and documentation, and evolve it at a predictable and well-tested cadence.

    That’s a big deal for us and for the Jenkins X community, and we’ll talk here about what it is, what it means, and how it impacts future Jenkins X open source development. Don’t worry, though – it’s all good news.

    What is CloudBees Jenkins X Distribution?

    Jenkins X is growing and evolving, rapidly. Every day it gets more stable, works better and does even more cool new stuff. The OSS community emerging around Jenkins X continues to grow and we want to see that accelerate even more. Open-source standards are good for the industry, and we believe next-gen CI/CD should be as community-driven and as open as Jenkins has been for the last 15 years.

    All that said – some organizations need to rely on something today. They need to know if and when the bits will change and what the change is. They need to know that what worked today will still work next month, where to get help and information and who to count on when they’re picking a tool to power their business.

    We’re creating the CloudBees Jenkins X Distribution to give teams who want to use Jenkins X but can’t go all-in on keeping up with the fast-paced open-source project. We feel this enables teams to use Jenkins X to solve their critical daily needs without limiting community innovation and participation.

    What’s in it, what’s not and where can I get it?

    The CloudBees Jenkins X Distribution doesn’t do everything Jenkins X does – it takes the most mature and critical bits, tests and documents them and then gives you a package of a ready-for-primetime slice of the wider OSS project.

    The distribution will roll in new features on a monthly basis – always tested and documented – and you’ll be able to see what’s coming and choose when to adopt it. We’ll never let any breaking changes get through unexpectedly.

    For example, the first release of CloudBees Jenkins X Distribution supports Google Kubernetes Engine (GKE) and preview environments, but not Amazon’s Elastic Kubernetes Service (EKS) or DevPods. These features will come – as will lots of other cool stuff! We will always be upfront so that you know exactly what will run well and what isn’t ready yet.

    The OSS project is there with more experimental features (and welcome arms) if you need one of those features sooner. You can find the full list of what the CloudBees Jenkins X Distribution supports to today, and download it, right here.

    If your team is adopting Jenkins X and wants the comfort of world-class support, CloudBees will stand by the distribution. You can buy paid support plans for the distribution to make sure your team has someone to call and help you out any time you need.

    How does this relate to the OSS world?

    CloudBees is an open-source company, and we want to see open-source standards continue to define how teams work. The CloudBees Jenkins X Distribution is not an attempt to pull oxygen away from the Jenkins X project – it’s the opposite. We know people need a level of trust to invest in new tool choices, and we want to bring that level of maturity to Jenkins X so more people can find it, love it and participate in it.

    The more people using CloudBees Jenkins X Distribution, the more Jenkins X workloads are running in companies all over the world. As a community, Jenkins X can learn from these companies to drive the OSS project, to validate strategic directions, and to get advice and support from the most mature adopters.

    This is a bet on JX and the OSS world for CloudBees, and we’re excited to make it.

    Additional resources

  • eBook – Building Cloud Native Apps Painlessly – The Prescriptive Guide to Kubernetes and Jenkins X

    eBook – Building Cloud Native Apps Painlessly – The Prescriptive Guide to Kubernetes and Jenkins X

    This new book explains how our industry has reached the cloud native era, which impacts how software applications are developed, tested, deployed and managed. Inside, you’ll read about how the future of modern application development can benefit from the powerful combination of Jenkins X and Kubernetes, providing developers a seamless way to automate their continuous integration (CI) and continuous delivery (CD) process.

    Written by well-known DevOps leaders including Robert Davies, Brian Dawson, James Rawlings and James Strachan, this definitive guide will help you understand:

    • The technical and business benefits of Jenkins X.
    • How developers can use Jenkins X to build cloud native apps.
    • The steps for getting started with Jenkins X.

    [su_button url=”https://www.cloudbees.com/resource/ebook/building-cloud-native-apps-painlessly” target=”blank” background=”#ef2d3f”]Download Now[/su_button]

  • eBook – CI/CD for Cloud Native Applications on Kubernetes

    eBook – CI/CD for Cloud Native Applications on Kubernetes

    CI-CD-for-Cloud-Native-Applications

    Teams often spend days manually setting up Jenkins, pipelines and implementing continuous integration/continuous delivery (CI/CD) effectively. Jenkins X comes with all the automation you need to be able to focus on your application code and tests.

    In this whitepaper, explore the business value Jenkins X brings to organizations who undertake the journey of continuous everything.

    • Automatic software releases with semantic versions, the creation of artifacts, Docker images and Helm charts
    • Automatic promotion of versioned artifacts across your environments via GitOps
    • Preview environments created on each pull request

    [su_button url=”https://www.cloudbees.com/resource/whitepaper/cicd-cloud-native-applications-kubernetes” target=”blank” background=”#ef2d3f”]Download Now[/su_button]

  • Opinionated Kubernetes and Jenkins X

    Opinionated Kubernetes and Jenkins X

    I recently wrote about how all the cloud platforms are all in Kubernetes and so are developers. It is an exciting time, but the problem for many is that this is a huge blank sheet of paper for how to build and deploy applications. A white space, a void, a limitless canvas of possibilities. Insert metaphors here.

    The problem as you may guess is that few people really like or are able to start with a blank canvas. I know I prefer to start with something working and iterate towards a solution, or be given some rails to stay on (again with the metaphors).

    Introducing the Jenkins X project – a Kubernetes-native continuous integration and continuous delivery platform for developing cloud native applications that was just introduced as a Jenkins Enhancement Proposal, sponsored by James Strachan.

    There is a lot to take in but at it’s heart, this is an open source opinionated way to do continuous delivery with Kubernetes, natively, without necessarily having to learn all the things I talked about in my last blog post. I shall attempt to explain what this is all about and why it matters to developers. As someone said on the jenkins-dev mailing list “We have the two glued together with baling wire and twine” – Jenkins X aims to simplify how to work with continuous delivery and Kubernetes.

    First and most importantly, a sneak peek at the logo:

    You can see the nautical theme leaking through (and Kubernetes). Whilst it is called Jenkins X, it is about quite a lot more than Jenkins.

    Jenkins X makes decisions for you

    Jenkins X presents itself to you initially as a handy sleek command line (a native binary you can install called jx – the debate is on as to how pronounce it). Let’s take a tour (sail?):

    > jx import my-app

    If you have an existing project, this will detect what type of project it is, build a pipeline for you (and a bunch of Kubernetes things, like Helm Charts), add it to your project and set it up in GitHub, WebHooks and all, build the project (run the pipeline) and deploy a version to a “staging” environment.

    If it looks ok, you can promote it to production:

    > jx promote —env production —version 1.0.1 my-app

    If something went wrong in production, you can roll back an app to any version (the version numbers are made for you):

    > jx promote —env production —version 1.0.0 my-app

    > jx get apps # list versions

    An environment is a well-established concept for web developers using continuous delivery: out of the box Jenkins X makes three of them for you (dev, staging and production), but you can make as many as you like. Environments have rules around how things are promoted into them (and they also have their own extensible pipelines, but you can just use them as-is to start).

    You can also create a Spring Boot microservice app:

    > jx create spring

    Answer a few questions and it will set everything up for you.

    Any changes you make to your app automatically are built, and if the build looks good, they go through to the staging environment. WebHooks are setup for you (if you are using GitHub) to smooth this over.

    For those looking at starting from pre-made apps, there are “quickstarts”:

    > jx create quickstart

    They are based on a growing set of starter apps, in a variety of languages and tech stacks.

    Review apps for your changes: Each pull request is built/tested, and a “review app” is made available in a temporary environment. That means each proposed change, before it goes to the default branch (master), has an environment made (temporary) that it can be tried out in. In GitHub, this shows up as a comment in the pull request:

    Project type detection

    As you can see, so far there is no editing or manual creation of pipelines, or scripting or setup, just importing or creating your app and go. This is powered by Draft “packs” (a handy project that came out of Azure). What you end up with is a Jenkinsfile in your project repository. You may want to edit it one day, or you may be happy with it as is! Jenkins is famous for being un-opinionated in what you do, but Jenkins X has strong opinions (but you can extend and customise).

    Deploying or promoting to environments

    Deploying happens via pipelines behind the scenes – when a change is pushed, or a version promoted. You don’t need to directly interact with Kubernetes if you don’t need to. A tool called Helm does the heavy lifting: Helm is used to package and perform installations and upgrade for your apps.

    Nautical theme intensifies

    There is a little more magic going on here with environments, which you don’t see at first. Each environment, for a team, is represented by a Git repository behind the scenes. Configuration as code is a well-established best practice these days, so why not use it to track deployments and initiate deployments. I also mentioned in my previous post how declarative Kubernetes is: it is perfect for keeping all config in a repository, of the desired system state.

    Each promotion is actually a pull request to a per-environment repository. This repository is made and managed for you (and kept outside of the main application code repository), you don’t have to look at it, but you can extend things there should you need to. Specific environment repositories may have different access rules, or be controlled by a different team (perhaps even deploy to a different cluster). Some have coined the term for this as “GitOps.” I first came across this concept on a WeaveWorks blog.

    I’ll try and explain this one with a diagram:

     

    The pipeline is actually split in the middle. On the left is the more familiar continuous integration pipeline. This works on pull requests, pre-release version of things and is all about testing (automated and manual review). The source of truth for this is the configuration in the applications repository: branches, pull requests and so on.

    The right-hand side is the continuous delivery pipeline. This kicks in when the application is ready to be updated with a new release. This is the “GitOps” repo behind the scenes that controls the state of things in Kubernetes. A promotion on this side is a pull request, and then a merge, from the staging repository to the production repository.

    Installing Jenkins X

    The jx command line has a jx install command that installs it into a Kubernetes cluster.

    The best experience initially is using Google’s excellent GKE service:

    > jx create cluster gke

    This will ask a few questions, and go and set it all up for you in a cluster set aside for Jenkins X (recommended). Jenkins X runs entirely as services on top of a Kubernetes cluster.

    > jx install

    Is designed to work with a Kubernetes cluster (if it already exists, recommendation is to have a cluster put aside for Jenkins X if possible). Amazon EKS support is coming (mostly it is around testing), that service is in beta/early access so it is still a work in progress, as is Microsoft Azures excellent AKS service.

    So where is Jenkins?

    Good question, thanks for asking. Well, it is behind the scenes. As you have seen, there was no direct interaction with Jenkins, but it is there, running the pipelines for continuous integration and continuous delivery of the respective repositories, and orchestrating things with Kubernetes.

    If you run jx get pipelines you can see URLs to the various pipelines that have been setup for you are part of interacting with Jenkins X.

    By the way, James Strachan has written an extensive blog on jenkins.io that really explores the Jenkins X project in-depth. Once you finish reading this blog, take a stroll on over there and read James’. He also provides several ways you can get involved in the project.

    What else can I do with the command line?

    Lots, the jx command line has built in help:

    jx open

    – open apps, services or pipelines in your browser

    jx activity

    – explains how things got to where they are, a history

    jx help

    jx get environments

    – list environments

    jx get apps

    – show the state of applications, what versions are in what environments.

    What’s next with Jenkins X

    There is a whole lot more to this, and lots more moving parts and services that are set up for you that are very useful, but it is best to head over to jenkins-x.io and have a look.

    This project is obviously in early stages (it is a JEP after all) and there is lots happening. Check out the Jenkins X community if you want to chat on slack, IRC, issues or email. Read the Jenkins Enhancement Proposal doc.

    CloudBees recently joined the Cloud Native Computing Foundation, which includes a lot of important cloud native tech, including (but not only) Kubernetes. It will be interesting to see communities grow around continuous integration, continuous delivery and Kubernetes.

     

    Michael Neale is a development manager at CloudBees. Michael is an open source polyglot developer. For his sins, he spent time at JBoss, working on the Drools project and then Red Hat, where he continually caused trouble on various projects. Post-Red Hat, Michael was one of the co-founders of CloudBees, seeing great opportunity in cloud technologies. His interest in the cloud is natural, as he is attracted to disruptive technologies. Michael lives and works in the Blue Mountains, just outside Sydney, Australia. He has no hobbies, as his hobbies tend to turn into work anyway. Mic’s motto: “Find something you love doing, and then you will never work a day in your life again.” Follow Michael on Twitter.

  • All You Need to Know About Jenkins X

    All You Need to Know About Jenkins X

    Jenkins X is an open source project that offers automated CI/CD for cloud native applications on Kubernetes. Now over a year old and under the auspices of the Continuous Delivery Foundation, the emerging interest and growing implementations of Jenkins X has developers learning more about this technology and what it can do for them.

    Using Jenkins X provides developers with a number of benefits including faster software delivery releases, simplicity of installation and configuration and enhances the business sustainability over time.

    In this blog post, I’ll answer some of the most common questions about Jenkins X and why it’s important to you.

    What is Jenkins X?

    James Strachan headshotSo what is Jenkins X? James Strachan, distinguished engineer at CloudBees and chief architect of Jenkins X, defines Jenkins X as an “open source opinionated way to do continuous delivery with Kubernetes, natively,” without worrying too much about the underlying infrastructure. Jenkins X supports all major cloud platforms including Amazon, Azure, Google, IBM Cloud, OpenShift and Pivotal. It is a sub-project of Jenkins and uses automation, tooling and DevOps best practices to increase development speed and improve CI/CD.

    With Jenkins X, Kubernetes can be leveraged without spending too much time and effort configuring the complex ecosystem. It reduces the complexities and provides a guided approach with the right selection of tools, all within a system that is easy to use and learn. Jenkins X ensures that when a project is started, it’s not necessary to spend a lot of time creating the structure and gathering the required files. If you need a Kubernetes cluster, all the tools can automatically be in working condition without worrying about installation and configuration. In fact, a single jx command in Jenkins X can create CD pipelines, Git repositories and set webhooks. The list of what Jenkins X does is vast, and grows daily.

    What is the difference between Jenkins and Jenkins X?

    Unlike Jenkins, Jenkins X is opinionated and built to work better with technologies like Docker or Kubernetes. Having said that, Jenkins and Jenkins X are deeply related as everything that is done with Jenkins X can be done with Jenkins, using several plugins and integrations. However, Jenkins X simplifies everything, letting you harness the power of Jenkins 2.0 and using open source tools like Helm, Draft, Monocular, ChartMuseum, Nexus and Docker Registry to easily build cloud native applications.

    In fact, it’s this selection of tools and processes that make Jenkins X special and different from Jenkins and any other CI/CD solution. For instance, Jenkins X defines the process, while Jenkins adapts to whichever process are wanted or needed. Jenkins X adopts a CLI/API first approach, relies on configuration as code and embraces external tools (e.g., Helm, Monocular, etc). On the other hand, Jenkins has a UI first approach with configuration via UI, and everything heavily driven by internal plugins. Additionally, the Jenkins X Preview environments enable developers to collaboratively validate changes integrated into the codebase by creating a running system per Pull Request.

    Why was Jenkins X started?

    Software development processes have completely transformed over the last few years and continue to evolve. With DevOps, developers’ responsibility for application and configuration management has significantly increased. While DevOps aims to improve the speed of development and reduce the risk of downtime, the transition from developer to the operational role hasn’t been very smooth for developers. Nonetheless, DevOps is gaining higher acceptance and adoption. At the same time, significant changes have taken the industry by storm.

    Microservices architecture: While the cloud with its several deployment models (public, private and hybrid) gained adoption across all industries, the challenge of deploying, managing and updating applications remained unresolved. This enabled a way forward for a microservices architecture. Unlike the monolithic apps, apps built on microservices can be deployed on smaller, independently deployable and scalable hosts. After taking a cue from the likes of Amazon, eBay, PayPal and Netflix, today most organizations are moving applications from the monolithic to the microservices architecture.

    Container ecosystem: Containers, which offer OS virtualization, gained popularity as they solve some of the problems associated with microservices. Today, different containers on the same host can deploy microservices built on different technologies and frameworks. This allows developers to use whatever language they are comfortable with and package the dependencies within the container itself. Containers are also more efficient than virtual machines (VMs), which virtualize only the hardware. Docker, which helped lead the container movement, has a huge repository of preconfigured Docker images in its Dockerhub public repository, which open-source communities use in abundance. These and many other advantages have made containers a default choice for deployment of code on the cloud.

    The rise of Kubernetes: While containers make things simpler, they are not free from challenges. In fact, they are similar to VMs when it comes to managing or orchestrating them. It is challenging for any organization to make sure that machines are not under or over provisioned and every dollar spent for memory, CPU, or storage is well accounted for. There was a need for a solution which allowed efficient and optimal operations with an ability to move containers around, automatically if possible. Google found this exact solution a long time ago and later introduced it in the form of Kubernetes. The open source solution simplifies installation, upgrades and orchestration of containers. Though other cloud vendors also offer their own solutions to orchestrate containers, Kubernetes is vendor-agnostic and offers a common platform for handling containers across all types of clouds and even an in-house infrastructure.

    Nonetheless, with all these changes, today developers have a lot of options within a fragmented open source ecosystem with numerous tools for CI/CD. Every tool is purpose-built to solve a part of the problem, but it’s not easy to choose the right ones. It can take years for an organization to gain a good enough understanding of CI/CD and develop an efficient setup. Developers often have to spend more time fine-tuning their CI/CD setup than work on real development. There’s also not a straightforward way to manage Kubernetes clusters and people are wary of the lack of effective monitoring for Kubernetes in production environments.

    Though Jenkins can help developers make the most of their CI/CD setup with Kubernetes, it is not easy to select the right combination of plugins and configuration which can all work in tandem with the code. Very few teams agree on what’s the best way to do CD on Kubernetes and many haven’t ever set up a Jenkins Pipeline.

    These challenges led the community to think about a solution which can leverage Jenkins to automate CI/CD in the cloud for those who haven’t used Kubernetes before or even those who are using Kubernetes but are struggling with CI/CD. The thought eventually took the form of the Jenkins X project.

    What are the main features of Jenkins X?

    Jenkins X kubernetes captainJenkins X is built for developers and is designed to help ship code faster, following the best practices in DevOps. That’s why it offers preview environments, simplifies cluster creation with DevEx and can run on different cloud providers’ clusters. One of the biggest advantages of using Jenkins X is that knowledge of Kubernetes internals isn’t necessary and developers can start leveraging the ecosystem right away. However, if it’s necessary to change the setup to fit specific environments or workflows tweaks can be made to the underlying Dockerfile, Jenkins X pipeline, Jenkinsfile or Helm charts as everything is versioned in Git. Let’s examine some of the most talked about features of Jenkins X:

    Automated CI and CD: Jenkins X offers a sleek jx command line tool, which allows Jenkins X to be installed inside an existing or new Kubernetes cluster, import projects and bootstrap new applications. Also, Jenkins X creates pipelines for the project automatically.

    Environment Promotion via GitOps: Jenkins X allows for the creation of different virtual environments for development, staging, and production, etc. using the Kubernetes Namespaces. Every environment gets its specific configuration, list of versioned applications and configurations stored in the Git repository. The promotion of new versions of applications between these environments is done automatically following GitOps practices. Moreover, code can be promoted from one environment to another manually and change or configure new environments as needed.

    Preview Environments: Though the preview environment can be created manually, Jenkins X automatically creates Preview Environments for each pull request. This provides a chance to see the effect of changes before merging them. Further, Jenkins X adds a comment to the Pull Request with a link for the preview for team members.

    You can learn more about all Jenkins X features here.

    What are the top 5 advantages of Jenkins X?

    Easier setup: Jenkins X offers build packs for different kinds of projects, automates the installation, configuration and upgrades of external tools (Helm, Skaffold, Monocular etc.), and helps developers get started quickly with a single line jx command. Moreover, developers have freedom to explore the internal plumbing of Jenkins X whenever deemed fit.

    Isolation: Every team gets to run its own instance of Jenkins X; either in a shared cluster or in their own separate clusters. Within a shared cluster, each team can have its own namespace and can effectively share resources while being able to have different pipelines, flows, and configuration as that used by other teams. With separate clusters, the teams get its own set of resources, and won’t be impacted by other teams’ workloads.

    Higher velocity: Jenkins X allows unhindered development without shipping logistics slowing things down. Powerful commands expedite most tasks and provide seamless integration with cloud or SCM. For example, a simple ”jx create cluster gke” command installs Jenkins X on Google cloud. AWS (EKS), Azure (AKS), Oracle (OKE) and more can also be used. Furthermore, the application code along with all necessary files for containers, packaging, and pipelines are stored in a common repository and are available out of the box.

    Faster recovery: GitOps creates a single source of truth with everything versioned and comments available for every pull request. The configuration as code, of both Jenkins X and your environments, allows developers to get the right context and traceable information to resolve outages faster.

    Predictable releases: Jenkins X helps create development/test environments using the “jx create devpod” command to provide each developer their own sandbox inside the Jenkins X cluster. As the devbuild pods are the same as those used in the pipeline used in production, it ensures code will perform in a predictable manner. Further, Jenkins X helps spin up Preview Environments before code is promoted to production. All these features help roll out stable code.

    How CloudBees can help developers get started with Jenkins X?

    Start off by subscribing to CloudBees Jenkins X Support for initial setup and keeping Jenkins X up-to-date, stable and compliant. CloudBees offers 24×7 technical support for both Jenkins and Jenkins X and is home to the largest group of Jenkins-certified engineers anywhere. You can also watch this video by James Rawling to learn more about Jenkins X.

     

    Additional resources