Jenkins / Online Meetup

Google Summer of Code (GSoC) is a global, online program focused on bringing new contributors into open source software development. GSoC Contributors work with an open source organization on a 12+ week programming project under the guidance of mentors.

As we are at the end of another successful season of Jenkins in GSoC, GSoC Contributors will be presenting the final status for their projects. Join them on this call as they present their final achievements, improvements they've made to the Jenkins project and lessons learned on this journey:

Plugin Health Scoring System by Dheeraj Singh Jodha
Jenkinsfile Runner Action for GitHub Actions by Yiming Gong
Automatic git cache maintenance on the controller by Hrushikesh Rao
Pipeline Step Documentation Generator Improvements by Vihaan Thora
Link to all projects: https://www.jenkins.io/projects/gsoc/

2022 GSoC Contributors have been working hard to improve the following projects. Join them on this call as they present their progress, lessons learned, and demos:

- Plugin Health Scoring System by Dheeraj Singh Jodha
- Jenkinsfile Runner Action for GitHub Actions by Yiming Gong
- Automatic git cache maintenance on the controller by Hrushikesh Rao
- Pipeline Step Documentation Generator Improvements by Vihaan Thora
- Link to all projects: https://www.jenkins.io/projects/gsoc/

Timecodes
0:00 - Intro
3:37 - Jenkinsfile Runner Action for GitHub Actions
18:11 - Plugin Health Scoring System
36:39 - Automatic Git Cache Maintenance on the Controller
52:13 - Pipeline Step Documentation Generator Improvements

Katharina Sick and Martin Singer from Dynatrace will show how they provision Jenkins instances on Demand with Kubernetes and Configuration as Code.

When developing a project, there are many things to consider. It's not just about the code itself, but also about building, testing and packaging everything. Making this process easier is the main goal for the Engineering Productivity teams at Dynatrace.

Join us in this talk to learn about how we are utilizing Jenkins to ease the process of building and delivering applications for hundreds of developers. You'll see how our Jenkins instances are running in a Kubernetes cluster, how they are provisioned via Configuration as Code with minimal overhead and which tools are used to get the most out of our workflow. Additionally, we'll add a live demo to show how all of these components can work together.

Speakers:

- Katharina Sick, Software Engineer at Dynatrace. Full stack software engineer at Dynatrace. Advanced from mobile to backend development and now putting more focus on full stack solutions as well as CI and CD environments.

- Martin Singer, Software Engineer at Dynatrace. Working on CI/CD topics since starting as a full time software engineer. Always eager to learn about new ways to automate processes.

Explore how Jenkins contributors use Crowdin Enterprise as localization tool in Jenkins. They use it to localize the messages and online help in Jenkins plugins. It simplifies the localization process for translators. They propose translations from a web browser, then a proofreader reviews, adapts, and approves the translation, and a GitHub pull request is submitted with the translation.

The tool feels like it fit very well into Jenkins development. They would like to show the tool so that others can help with translations.

Jenkins Online Meetup: Jenkins in Google Summer of Code 2022
February 23, 2022

00:00 - Introduction
01:34 - Agenda
02:10 - Intro to Google Summer of Code
03:05 - Jenkins in GSoC 2022
09:44 - Project Ideas
22:32 - Project Presentations by Mentors
22:58 - Automatic Git Cache Maintenance
24:30 - Automatic Spec Generator for Jenkins REST API
26:18 - Jenkinsfile Runner Action For GitHub Actions
27:41 - Pipeline Step Documentation Generator
28:51 - Plugin Installation Manager Tool Improvements
30:09 - Plugin Health Scoring System
32:28 - Jenkins Config as Code (JCasC) Drift Detector

Ulli Hafner shares the techniques that he uses to help students in his courses at the Munich University of Applied Sciences as they use Jenkins plugin development as part of their coursework.

His configuration is available from https://github.com/uhafner/warnings-ng-plugin-devenv#readme

00:00 Welcome and introductions
06:20 Introduction to a development environment for Jenkins
10:20 Three components - scripts, containers, and an IntelliJ project
12:55 Using Jenkins interactively in the development environment
15:00 Using the development environment
28:00 Additional runners for unit tests, integration tests, and UI tests
37:09 Configuration as code for the development environment
44:06 Debugging controllers and agents in the development environment

Hacktoberfest launch as part I of the Jenkins Contributor Summit October 2, 2021. Includes guidance and examples for new contributors to assist with

* User experience improvements
* Plugin documentation migration to GitHub
* Content Security Policy improvements for core and plugins
* Plugin modernization

00:00 Introduction
05:29 Welcome to Hacktoberfest
15:06 User experience improvements
38:50 Migrating plugin documentation to GitHub
56:09 Implementing Content Security Policy
1:50:33 Modernizing plugins
2:28:30 End of the session

Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/281083403/

Wise people say that “running Jenkins in a cloud environment is not a trivial task”. Find out how we aim to simplify that, using the Jenkins Operator for Kubernetes.

The trend to move infrastructure to cloud is undeniable. Jenkins has been of great help with building applications for countless developers for over a decade now, but it does have its limitations. Running it in a cloud environment is nothing but a trivial task. See how we can leverage the new and exciting technologies such as Kubernetes and Operator SDK to overcome the shortcomings. As a result achieve truly scalable and robust Jenkins in the cloud using the Jenkins Operator.

References:

- Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/278322004/
- GitHub repository: https://github.com/jenkinsci/kubernetes-operator
- Website: https://jenkinsci.github.io/kubernetes-operator/
- Roadmap: https://github.com/jenkinsci/kubernetes-operator/blob/master/ROADMAP.md

Speakers:

Mateusz Korus - a DevOps Engineer at VirtusLab with experience working with high-traffic cloud infrastructure. Enthusiastic about reactive technologies and the observer pattern. Tea enjoyer.

Piotr Ryba - a DevOps Engineer at VirtusLab, working on the Jenkins Operator project. During his professional work, he wore many hats ranging from Software Development to IT Operations. Experienced in programming mobile apps and microservice applications.

Recording of the online Meetup on May 14, 2021. Presenters: Vibhav Bobade, James Strachan, Gareth Evans.

Kubernetes has become the staple for cloud native infrastructure today. With the rise of the microservice architecture and focus on container based serverless solutions, CI/CD solutions also have to adhere to what works best on Kubernetes.

Tekton is a Pipeline engine which checks all the boxes for a performant Cloud Native CI/CD solution. It provides users the ability to create composable pipelines which run on serverless workloads in Kubernetes. And now it is possible to use Tekton itself via Jenkins. With the Tekton Client Plugin, the user would be able to manage Tekton resources from their Jenkins instance and run Tekton Pipelines in the cloud. In this meetup we will discuss and demo how one can configure the Tekton Client Plugin and use it to deploy to Kubernetes in an efficient and Cloud Native fashion.

References:
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/278067201/
* Slides: https://docs.google.com/presentation/d/1voA1RR2U74GG0rzd4BGruslWgUmIZWR69n8mDqo2POk/edit?usp=sharing
* Plugin repo: https://github.com/jenkinsci/tekton-client-plugin
* Tekton: https://tekton.dev/
* Blogpost by James Strachan: https://cd.foundation/blog/2020/11/05/bridging-the-gap-with-tekton-client-plugin-for-jenkins/

Join the Cloud Native SIG channels to meet presenters and to ask any questions! https://www.jenkins.io/sigs/cloud-native/

DevOps World, formerly known as Jenkins World, is one of the largest online events which includes various tracks for automation practitioners, and various community and open source sessions. This year this will be a virtual event on September 28-30. There will be multiple tracks, including the Community and the Continuous Delivery Foundation tracks. Any Jenkins-related talks are welcome! The Call for Papers Deadline is May 20, 2021.

During this session speakers and program committee members introduce the Jenkins community agenda and then talk about the call for papers and the application guidelines. Then we will have a Q&A session where we will answer any questions from the meetup participants. Join us if you are interested to submit your talk!

Links:
* Slides: https://docs.google.com/presentation/d/1qBjE-0Y3D6gLYl-Ql9h3aM1mEIxoqClh2T8d_o2QtNA/edit?usp=sharing
* https://www.devopsworld.com/
* https://devopsworld.submittable.com/submit/191660/devops-world-call-for-papers

DevOps World, formerly known as Jenkins World, is one of the largest online events which includes various tracks for automation practitioners, and various community and open source sessions. This year this will be a virtual event on September 28-30. There will be multiple tracks, including the Community and the Continuous Delivery Foundation tracks. Any Jenkins-related talks are welcome! The Call for Papers Deadline is May 20, 2021.

During this session Alyssa Tong and Oleg Nenashev will introduce the Jenkins community agenda and then talk about the call for papers and the application guidelines. Then we will have a Q&A session where we will answer any questions from the meetup participants. Join us if you are interested to submit your talk!

Links:
* Slides: https://docs.google.com/presentation/d/1qBjE-0Y3D6gLYl-Ql9h3aM1mEIxoqClh2T8d_o2QtNA/edit?usp=sharing
* https://www.devopsworld.com/
* https://devopsworld.submittable.com/submit/191660/devops-world-call-for-papers

Jenkins is a very diverse project with many opportunities to contribute and many technology stacks. Some examples: Java, Javascript, Golang, Groovy, Docker, Kubernetes. And it is not only about code, we are continuously looking for non-code contributions: documentation, testing, design, and spreading the word. We always welcome experienced and newcomer contributors to join the community.

At this meetup we talk about contributing to Jenkins and how to get started. We will also talk about various outreach projects and specifically about Google Summer of Code which is starting soon. There is also a Q&A session where we answer questions from participants.

Jenkins 2.277.1 is the most recent Jenkins long term support (stable) release. It was released March 10, 2021 with breaking changes in specific areas that improve the Jenkins experience and provide foundational improvements to Jenkins internal components.

Major breaking changes include:

* Configuration Form Modernization (aka Tables-to-Divs)
* JEP-227 - Update of Acegi Security to Spring Security
* JEP-228 - Unforking XStream
* ASM Library Update
* Replacement of old system properties

Additional changes include:

* Plugin Manager Performance Improvements
* Support for specifying “Preparing to Shutdown” reasons
* New color palette in tab controls
* Performance improvements
* Dependency updates

Presentation noted that this upgrade is different than typical Jenkins LTS upgrades because it needs plugin upgrades in the same steps as the Jenkins core upgrade. Steps recommended are:

* Review the upgrade guide
* Remove unused plugins
* Update plugins before Jenkins 2.277.1 upgrade
* Upgrade to Jenkins 2.277.1
* Update plugins after Jenkins 2.277.1 upgrade

Panel discussion session with Jesse Glick, Tim Jacomb, and Félix Queiruga highlighted more details of the process upgrade process and more ways that Jenkins users and developers can have a better experience with the upgrade.

Oleg Nenashev describes the process and timeline of the Jenkins long term support releases. He notes how Jenkins weekly releases are curated and collected to a selected baseline. The baseline is augmented with additional backported changes based on issues discovered in later weekly releases.

Luke O'Malley presented an overview of semgrep, a fast static analysis tool that supports many languages. He shared the techniques they use to included static analysis in their Jenkins jobs and areas (like code review) where they've found static analysis can be surprisingly helpful.

Zainab Abubakar shares her experiences Documenting Jenkins on Kubernetes as part of Google Season of Docs 2020. Her project is described at https://www.jenkins.io/sigs/docs/#jenkins-on-kubernetes .

Jenkins Online Meetup for Hacktoberfest 2020. Includes suggestions for areas to contribute including code, documentation, and more. Provides a demonstration of building the jenkins.io site locally for development, examples of submitting pull requests from github.com, and a migration of plugin documentation from the Jenkins wiki to GitHub.

Presentation by Loghi Perinpanayagam, a GSoC 2020 student. The main goal of this project is integrating Machine Learning workflow including Data preprocessing, Model Training, Evaluation and Prediction with Jenkins build tasks. This plugin will be capable of executing code fragments via IPython kernel as currently supported by Jupyter Notebook. Kernels which are already installed can be configured for each build step and dumping visuals is an added feature in the plugin.

Machine Learning has evolved rapidly in the software industry for recent years. Jenkins CD/CI can be a good practice to deliver a high reliable product in the end. Machine Learning plugin can be used to build Jupyter Notebooks and script files with proper kernel configurations. In addition, the build wrappers could be used to convert Jupyter Notebooks to python/JSON and/or copy the files to the workspace for more actions.This Machine Learning plugin will endeavour to satisfy the data science community together with the help of other plugins. Success of this plugin will definitely serve much benefits to the community and Jenkins.

References:
* Project page: https://www.jenkins.io/projects/gsoc/2020/projects/machine-learning
* Plugin page: https://plugins.jenkins.io/machine-learning/
* Repository: https://github.com/jenkinsci/machine-learning-plugin

Presentation by Sladyn Nunes, GSoC 2020 student in the project. The main idea behind the project is to build a customizable jenkins distribution service that could be used to build tailor-made jenkins distributions. The service would provide users with a simple interface to customize the configuration, they want to build the instance with eg: plugins,jenkins version, docker image etc. Furthermore it would include a section for sharing community created distros so that users can find and download already built jenkins war/configuration files to use out of the box.

Talk abstract: We would be going through how to add plugins to the configuration and the various package configuration details that need to be entered so that the service can easily generate a packager-config.yml, essentially the first step of generating a fully usable jenkins.war, we would then go through the process of downloading a war file as well as taking a look at how one would go about accessing the community configurations.

References:
* Project page: https://www.jenkins.io/projects/gsoc/2020/projects/custom-jenkins-distribution-build-service
* Main repository: https://github.com/jenkinsci/custom-distribution-service

Presentation by Kezhi Xiong, GSoC 2020 student in the Jenkins project The GitHub Checks API allows developers to report the CI integrations’ detailed information rather than the binary pass/fail build status on GitHub pages. This project is about implementing this API as a new Jenkins plugin. By consuming this API, other plugins can easily create GitHub checks. Thus, any information during the Jenkins process like warnings, summaries, and durations can be directly shown on GitHub pages.

Talk abstract: In this talk, I’ll go through what GitHub check run is, how it could benefit the developers. Then, I’ll present how Jenkins plugins could integrate with that, and how Warnings NG and Code Coverage API plugins integrate with GitHub Checks.

References:

* Project page: https://www.jenkins.io/projects/gsoc/2020/projects/github-checks
* Checks API Plugin: https://plugins.jenkins.io/checks-api/
* GitHub Checks API Plugin: https://plugins.jenkins.io/github-checks/

Presentation by Buddhika Chathuranga, a GSoC 2020 student in the Jenkins organization. On Windows machines, Jenkins server and client can be installed as Windows Services in order to get better robustness and manageability within the system. This is a functionality bundled into the Jenkins core directly. When installed as a service, Jenkins uses the Windows Service Wrapper executable (.NET, written in C#) which is being configured by XML config files. Currently, there are only a few configuration checks there (no XML Schema, limited validation, etc.), and it’s often that the service wrapper is misconfigured by Jenkins users. In this project I update Windows Service Wrapper to support YAML files as configuration inputs and to introduce better configuration validation during the service installation and startup. Usage of YAML should simplify configuration management in Jenkins, especially when automated tools are used.

Talk abstract: In the presentation I will talk about a brief description about Windows service wrapper. Then I will talk about project tasks. Under that first I will talk about YAML configuration support. Then about the new CLI and XML schema file. End of the talk I will demo on YAML configuration support and YAML verification with the JSON Schema.

References:

* Project page: https://www.jenkins.io/projects/gsoc/2020/projects/winsw-yaml-configs
* Repository: https://github.com/winsw/winsw
* YAML Support Documentation: https://github.com/winsw/winsw/blob/master/doc/yamlConfigFile.md

Quick introduction to the Jenkins project in Google Summer of Code 2020. Presented by Martin d'Anjou, a Jenkins GSoC org team member. More information about Jenkins in GSoC: https://www.jenkins.io/projects/gsoc/

Presentation by Sumit Sarin, a GSoC 2020 student in the Jenkins project. File fingerprinting is a way to track which version of a file is being used by a job/build, making dependency tracking easy. The fingerprint engine of Jenkins can track usages of artifacts, credentials, files, etc. within the system. It does this by maintaining a local XML-based database. This leads to dependence on the physical disk of the Jenkins master. This project involved extending Jenkins core to support storing of fingerprints in an external storage, along with two reference implementations, backed by Redis and PostgreSQL respectively. Various functionalities like migration and cleanup were developed and released. Users can now use these plugins to externalize the storage of their fingerprints. This project was one step forward in developing a cloud native Jenkins.

Talk abstract: This presentation will start with a brief introduction about the fingerprinting engine in Jenkins and its use case. Then we will discuss the motivation behind externalizing these fingerprints. We will discuss the external fingerprint storage API built during the course of the project, and what features it allows the plugin developers to use. Then we will talk about the two reference implementations built by us during the project, backed by Redis and PostgreSQL. We will discuss fingerprint cleanup and migration strategies. A demo will be presented which will show the working of the plugins and their functionality in action. We will conclude the presentation with what potential future areas of improvement can be for this project where the community is more than welcome to contribute. And lastly a short Q&A with the developers behind this project.

References:

* Project page: https://www.jenkins.io/projects/gsoc/2020/projects/external-fingerprint-storage/
* Redis Fingerprint Storage Plugin: https://github.com/jenkinsci/redis-fingerprint-storage-plugin/
* PostgreSQL Fingerprint Storage Plugin: https://github.com/jenkinsci/postgresql-fingerprint-storage-plugin
* JEP: https://github.com/jenkinsci/jep/tree/master/jep/226

Recording of the Jenkins Online Meetup on Aug 19, 2020. Presenters: Tim Jacomb and Kezhi Xiong. GitHub Apps authentication support was released in April as a part of the GitHub Branch Source plugin. It is a huge improvement for the Jenkins community, especially for users using Multi-Branch Pipeline and GitHub Org folders. It brings us many benefits: larger rate limits, user-independent authentication, improved security and fine-grained permissions, access to GitHub Checks API.

Based on GitHub Apps authentication support, we have recently released an initial version of Checks API plugin and GitHub Checks plugin. The two plugins are about defining and implementing the checks API in Jenkins. By consuming this API, other plugins can easily create GitHub checks. Thus, any information during a Jenkins build like warnings from static analysis tools, code coverage, and test results can be directly shown on GitHub UI.

In this webinar, we will go through the benefits of GitHub Apps,how to set them up for Jenkins, how to consume the checks API in Jenkins plugins or pipelines and show you examples on how we used the API to report static analysis issues and code coverage to GitHub.

References:
* GitHub Apps Authentication Blogpost: https://www.jenkins.io/blog/2020/04/16/github-app-authentication/
* GitHub Checks API project update: https://www.jenkins.io/blog/2020/08/03/github-checks-api-plugin-coding-phase-2/
* Checks API Plugin: https://github.com/jenkinsci/checks-api-plugin
* GitHub Checks Plugin: https://github.com/jenkinsci/github-checks-plugin
* Warnings NG plugin: https://plugins.jenkins.io/warnings-ng/
* Code Coverage API plugin: https://plugins.jenkins.io/code-coverage-api

Starting from July 2020, all Jenkins weekly and LTS releases are built and shipped by the new release infrastructure. Want to know how Jenkins builds Jenkins? Catch this session to see the real-life implementation of Jenkins’ development (ci.jenkins.io) and delivery (release.ci.jenkins.io) infrastructure in the cloud as it evolved from a mix of platforms to multi-platform virtual machines, containers and Kubernetes on Microsoft Azure. Expect a frank discussion of issues that were encountered along the way, how the architecture has evolved and what’s on the roadmap. We’ll share important tips and tricks for implementing your own Jenkins infrastructure on any cloud, based on my own Jenkins’ implementation experience.

Presenter: Olivier Vernin, Jenkins Infrastructure Officer

References:

* Slides: https://docs.google.com/presentation/d/1c-Vax7TGCHU41RynLV2GYQyavaYjfEptkbwepg3IN9k/edit?usp=sharing
* https://www.jenkins.io/projects/infrastructure/
* https://github.com/jenkins-infra/release
* https://issues.jenkins-ci.org/browse/INFRA-910
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/272271879/

In this session, Aytunc Beken will demonstrate Pipeline As YAML plugin usage starting with basic to advanced Pipelines. The plugin allows defining Jenkins Pipelines in a declarative form, using YAML files. This is an incubating project, any feedback and contributions would be welcome!

Agenda:
* Introduction to the plugin
* Basic Pipeline
* Environment Variables / Options / Agent definitions / Post Actions
* Complex Stages ( Inner / Parallel Stages )
* Steps/Scripts Examples with Pipeline Libraries

References:
* Slides: https://docs.google.com/presentation/d/1J3EMR88K1hHY9zUjTWfiLq2Zcs1G4yaxKo1bwau_0ac/edit?usp=sharing
* Plugin page: https://plugins.jenkins.io/pipeline-as-yaml/
* Demo repo: https://github.com/aytuncbeken/pipeline-as-yaml-tutorials
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/271691294/

About the speaker: Aytunc works as an Expert DevOps Engineer. He likes to contribute to Jenkins Community in his free time.

Openshift has been making Jenkins available to it’s users as a primary CI/CD tool for a few years. Our users and customers are happy with it because it seamlessly integrates with the Openshift ecosystem. This talk will showcase the Jenkins Operator on Openshift. The Operator allows users to manage and use their Openshift supported Jenkins instances. We are excited to share new features that have been added to the Operator since our last Jenkins Online Meetup on the Openshift Operator for Jenkins.

References:
* Slides: https://docs.google.com/presentation/d/1As3eMYEiyBsEILfpvEMjpP1s-pJ0OeyVAuPZtXrjAGA/edit?usp=sharing
* https://github.com/jenkinsci/kubernetes-operator
* Jenkins Operator for RedHat - https://github.com/redhat-developer/jenkins-operator
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/271690719/

About the speaker: I work at Red Hat as a Software Engineer in the Jenkins Team. I maintain Openshift specific Jenkins plugins with my team and contribute to Tekton and Helm on the side. In my free time, I play guitar, do programmatic art using processing or go for a run.

Soon we are going to introduce a new public Jenkins roadmap. It will highlight the key initiatives happening in the Jenkins project: new features, documentation, infrastructure, developer tools, and community. It will help Jenkins users, contributors, and vendors to properly plan their work and to contribute to the projects they are interested in.

During this meetup Oleg Nenashev will present the current roadmap draft and initiatives which have been already added by special interest groups, sub-projects, and plugin teams. We will also discuss the public roadmap process and how to add your initiatives to the roadmap.

References:
* Slides: https://bit.ly/jenkins-meetup-roadmap
* Roadmap: https://www.jenkins.io/project/roadmap/
* JEP-14: https://github.com/jenkinsci/jep/tree/master/jep/14
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/271768902/

Jenkins 2.235.1 is the most recent Jenkins long term support release. We will introduce the new features in 2.235.1 and review how you can best use them: Plugin manager UX improvements, User interface refinement, new System read and Manage permissions. We will also talk about what's next in the Jenkins core.

Presenters: Mark Waite, Tim Jacomb, Mike Cirioli, Oleg Nenashev. Date: June 25, 2020

References:

* Slides: https://bit.ly/new-in-jenkins-2-235
* Jenkins 2.235.1 changelog: https://www.jenkins.io/changelog-stable/#v2.235.1
* Jenkins 2.235.1 upgrade guide: https://www.jenkins.io/doc/upgrade-guide/2.235/#upgrading-to-jenkins-lts-2-235-1

In many organizations up to 80% of pipeline execution time is spent in manual build validation steps. How can we reduce that? One option is applying Google's SRE (Site Reliability Engineering) practices by automating SLI (Service Level Indicators) & SLO (Service Level Objectives) based build validation. This method has proven to detect problematic issues in production and also allows us to automatically approve or reject builds being pushed through our pipelines. The side benefit is that once code passes our pipelines we have already been validating it with SLIs/SLOs relevant for production as well.

This is a presentation by Andreas Grabner, Dynatrace. In this session you learn the basics of picking good SLIs & SLOs and how to extract them from your monitoring tools. After this session you will be able to start implementing this integration yourself with Jenkins. To give you a jump start you will be introduced to the open source project Keptn (www.keptn.sh) which provides automated SLI/SLO-based quality gates. Then we'll talk about Keptn Jenkins Shared Library which integrates Jenkins and Keptn with just a couple of function calls.

References:

* Slides: https://www.slideshare.net/grabnerandi/jenkins-online-meetup-automated-sli-based-build-validation-with-keptn
* Keptn Jenkins Shared Library: https://github.com/keptn-sandbox/keptn-jenkins-library
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/270861119/

This session concludes the Jenkins UI/UX Hackfest. It will happen on June 01, 2PM UTC. Thanks to everyone who contributed to the project during this event, we have delivered a number of important changes which will help Jenkins users!

At this session we will celebrate the key results and achievements, events statistics and the data we have collected during the event. We will also talk about the next steps (swag, feedback, etc.).The session will be held in Zoom Webinar. RSVP to get a link.

References:

* Main Hackfest page: https://www.jenkins.io/events/online-hackfest/2020-uiux/
* List of contributors: https://github.com/jenkinsci/ui-ux-hackfest-2020#contributors

On May 29, 3PM to 5PM UTC we have had demo session where some of hackfest participants presented their demos

Demos:
* Félix Queiruga - Migrating Jenkins config layouts from tables to divs
* Tim Jacomb - Dark Theme for Jenkins
* Oleg Nenashev - Evaluation and Test environments for Read-only Jenkins Configuration and the Dark Theme
* Wadeck Follonier - New Script Security approvals management UI
* Mark Waite, Vlad Silverman - Documentation migration highlights
* Oleg Nenashev, Mark Waite - How to develop jenkins.io locally?

Links:
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/270932348/
* Opening slides: https://docs.google.com/presentation/d/1uUwIE2m-krnN3aUPMKQcUTSbwtpeVaO5ZUFrU_MK4sM/edit?usp=sharing

Target audience: Jenkins developers and advanced users. Presenter: Tim Jacomb.

Tim will take us through the System Read permission and the new ‘read-only’ Jenkins UI. We will enable System Read, see what’s available in each of the 3 read-only permissions and then will do a dive into the code, showing some of strategies required for controls to behave in a read-only manner. Then we will try and add system read support to a plugin during the demo.

References:

* Announcement blog: https://www.jenkins.io/blog/2020/05/25/read-only-jenkins-announcement/
* Jenkins JEP-224: https://github.com/jenkinsci/jep/tree/master/jep/224

In this presentation we will show how to use custom Web UI themes in Jenkins. We will take a look at the Simple Theme Plugin and available themes, and then we will configure our instance to use one of the themes. Then we will try to create a custom theme for our instance.

Presenters: Tobias Gruetzmacher, Oleg Nenashev and Tim Jacomb

Agenda:
* Introduction to the Simple Theme Plugin
* How to do a small changes to the UI?
* How to do a bigger theme or to create a new one?
* Jenkins Dark Theme project
* How to contribute to Jenkins themes? UI/UX Hackfest

Slides: https://docs.google.com/presentation/d/19N4B7BXu_Zfw8IDdUAZl_83-jXDAvwWC2KI6BvvNUCI/edit?usp=sharing

Jenkins Is The Way is a collection of experiences from all around the world showcasing how users are building, deploying, and automating great stuff with Jenkins. Alyssa will present the program, highlight some recent user stories and explain how to submit your story.

Materials:
* Program website: https://jenkinsistheway.io/
* Slides: https://github.com/jenkinsci/ui-ux-hackfest-2020/blob/master/presentations/03-jenkins-is-the-way-intro/slides.pdf
* Announcement blogpost: https://www.jenkins.io/blog/2020/04/30/jenkins-is-the-way/
* Hackfest page: https://www.jenkins.io/events/online-hackfest/2020-uiux/

Oleg will show how to migrate a plugin documentation from Jenkins Wiki to GitHub. We will take a plugin and perform a full migration of the docs: initial export, copy editing of the pages, moving changelogs to GitHub releases, creating a pull request to the plugin and finally doing a plugin release.

Materials:
* Plugin migration guide: https://www.jenkins.io/blog/2019/10/21/plugin-docs-on-github/
* Export tool: https://jenkins-wiki-exporter.jenkins.io/
* Event page: https://www.jenkins.io/events/online-hackfest/2020-uiux/
* Migrated plugin: https://plugins.jenkins.io/chucknorris/
* Pull request from the session: https://github.com/jenkinsci/chucknorris-plugin/pull/99

Mark Waite reviews the goals of the Jenkins Wiki migration project. He demonstrates the steps to collect, transform, and publish content from the Jenkins Wiki site to the Jenkins documentation site (jenkins.io). He shares the categories of information on the Wiki and how we’ve prioritized the effort to include that information in the Jenkins documentation. A page is migrated from the wiki. It identifies likely problems and discusses how contributors can resolve those problems.

The session also shows how to report your Hackfest contributions at https://github.com/jenkinsci/ui-ux-hackfest-2020/issues/new/choose .

References:

* Contributing: https://github.com/jenkins-infra/jenkins.io/blob/master/CONTRIBUTING.adoc
* Slides: https://docs.google.com/presentation/d/1fiVoDFrSNTOHsHT4cIqyOIBKYXG0q5zVn_XPue_Khkw/edit?usp=sharing
* Reporting progress: https://github.com/jenkinsci/ui-ux-hackfest-2020/issues/new/choose

In order to improve the look and feel of reporter plugins (like JUnit, Code Coverage, Static Analysis, etc.) it makes sense to use some modern JavaScript libraries and components. This presentation by Ullrich Hafner introduces a few new UI components that can be used by plugin authors to provide a rich user interface for reports in Jenkins.

The following new components are shown in the session:
* bootstrap4-api-plugin: Bootstrap is the world’s most popular front-end component library to build responsive, mobile-first projects on the web.
* data-tables-api-plugin: DataTables is a highly flexible tool, built upon the foundations of progressive enhancement, that adds a lot of features to any HTML table.
* echarts-api-plugin: ECharts is an open-sourced JavaScript visualization tool to create intuitive, interactive, and highly-customizable charts.
* font-awesome-api-plugin: Font Awesome has vector icons and social logos, it is the web’s most popular icon set and toolkit with currently more than 1,500 free icons.

Links:
* Blogpost: https://www.jenkins.io/blog/2020/03/17/ui-plugins/
* Hackfest page: https://www.jenkins.io/events/online-hackfest/2020-uiux/
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/270767392/

On May 25-29 we will be organizing an online UI/UX hackfest, and we invite you to join this event! The goal is to get together and improve the Jenkins user experience, including but not limited to user interface and user documentation. We also invite you to share experiences about Jenkins and to participate in UX testing. Everyone is welcome to participate, regardless of your developer experience and time you could dedicate. Newcomers are welcome. The event follows the Jenkins is the Way theme and the most active contributors will get special edition swag and prizes!

At this online meetup the organizing team and project leaders will talk about the hackfest and answer questions from participants:
* Hackfest program overview
* Communication channels and events
* How to participate and contribute? How to report contributions?
* Track introductions: “User Interface”, “User Documentation”, “Spread the Word”
* Q&A

Links:
* Event page: https://www.jenkins.io/events/online-hackfest/2020-uiux/
* Registration to hackfest: https://forms.gle/8A4jJwDVCekLp9ER8
* Slides: https://docs.google.com/presentation/d/1wZpEnD6AkIiufNuvzbJZJhj649fBBAXkeQrOnaU8A-E/edit?usp=sharing
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/270644129/

Recording of the Online Jenkins Meetup on May 19, 2020. Presenter: Nicolaj Græsholt, Eficode Praqma. Journey with Nicolaj, as he talks about the pains of managing a manually configured job in Jenkins; converts a Freestyle Job to JobDSL, instantly; introduces mechanisms for adding the jobs to Jenkins, as code; and ultimately converts the job to a Jenkins Pipeline!

Just like last time, in the talk “Configuration as Code of Jenkins (for Kubernetes),” you’ll see plenty of live demos and get to take home all the code and examples afterwards. Use it as the starting point for taking advantage of the Configuration as Code (CasC) that everyone is talking about, and hopefully it will save you a lot of headache in the future!

Links:
* Slides: https://github.com/figaw/freestyle-to-pipeline-jenkins/blob/master/from-freestyle-jobs-to-pipeline-with-jobdsl.pdf
* Demo repository: https://github.com/figaw/freestyle-to-pipeline-jenkins
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/270600737/

Maven is widely used for Jenkins plugin development, more than 90% of plugins use it. In order to simplify plugin development, the Jenkins project offers a standard Parent POM which defines the recommended build, verification and release flow. Such parent POM helps us to ensure quality of the Jenkins plugins. In April 2020 we released a new major release of the parent POM which includes a number of important and sometimes incompatible changes: Jenkins core Bill of materials, full migration to SpotBugs, etc.

In this presentation James Nord from CloudBees will talk about the changes introduced in Plugin POM 4.0. What do plugin developers and users get by upgrading? How to upgrade? What obstacles to expect, and how to resolve them?

Links:
* Slides: https://drive.google.com/file/d/1uQaEA_EYk3g1D_QoJXK_0VujQtnhD4zq/view?usp=sharing
* Plugin Parent POM repository: https://github.com/jenkinsci/plugin-pom
* 4.0 changelog: https://github.com/jenkinsci/plugin-pom/releases/tag/plugin-4.0

Tomasz Sęk from VirtusLab shows how to manage Jenkins in with the Jenkins Operator for Kubernetes: https://github.com/jenkinsci/kubernetes-operator. This is a recording of the Jenkins Online meetup on May 11, 2020.

In presentation Tomasz will explain how operator pattern helps to manage Jenkins in Kubernetes. We will take a look at the operator pattern and its use cases. A closer look at the Jenkins Operator will show the operator pattern in practice. Then we will go through day-to-day operations automation that the operator provides like deployment, configuration and repair of a Jenkins instance. After this presentation you will know how a non-cloud native application can be run in an immutable, scalable and secure way.

* Slides: https://github.com/jenkinsci/kubernetes-operator/blob/master/assets/Jenkins_Online_Meetup-Jenkins_Kubernetes_Operator.pdf
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/270363389
* Q&A: use the project's chat: https://github.com/jenkinsci/kubernetes-operator#community

Presenter: Nicolaj Græsholt, Continuous Delivery and DevOps Consultant and Trainer from Eficode Praqma. You have Jenkins running in production, but would like a better way to manage it, e.g. so Kubernetes can manage it for you. Fortunately all the building blocks have already been made by the Jenkins community, but there are many elements that you need to get right. Nicolaj will show you how you can go from a completely manually configured Jenkins master to an everything as code setup in Kubernetes.

You will see how this can be achieved using JobDSL, Pipeline, JCasC and Helm3 and after this talk you'll get access to all the examples and be able to convert your Jenkins to a configuration as code setup!

Agenda:
- From a job configured through the UI to code, instantly with JobDSL
- Configuring your Jenkins with JCasC
- Installing your new Jenkins on Kubernetes with Helm3

Links:

* Slides: https://github.com/figaw/configuration-as-code-jenkins-k8s/blob/master/configuration-as-code-jenkins-k8s.pdf
* Demo repository: https://github.com/figaw/configuration-as-code-jenkins-k8s
* Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/270042451/
* Offline Q&A: #jenkins-ci chat in the Kubernetes Slack

Presenter: Marky Jackson, Anchore

One of the strongest sides of Jenkins is that it has a scaling feature almost out-of-the-box, but these features need additional configuration and the infrastructure layer. There are many ways to implement Jenkins scaling: to build parallelization, on-demand agents, etc. One of the powerful options available right now is Jenkins scaling on top of Kubernetes and in this presentation. Marky, an active Kubernetes and Jenkins contributor, will show you how to do just that.

This presentation covers the following:
* How to get Jenkins running natively on K8s?
* Provisioning on-demand agents with Kubernetes Plugin
* Live Demo

Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/269888701/
Slides by Marky: https://docs.google.com/presentation/d/1r3S3T8VXePv7qwPAo5dlFe1PgaHS3ui4dR-Vjlo8XXE/edit?usp=sharing
Demo: https://github.com/markyjackson-taulia/jenkinsci-on-kubernetes

Note: There are a few areas where the sound has been removed via editing

Google Summer of Code (GSoC) is an annual, international, program which encourages college-aged students to participate with open source projects during the summer break between classes. The Jenkins project will participate in GSoC 2020 as a mentoring organization. This online meetup online meetup provides introduction to potential GSoC students who are interested in the Jenkins project. Agenda:

- GSoC Org Admins - Introduction to GSoC and Jenkins in GSoC
- Project presentations by potential mentors
- Questions and Answers

Links:
* Online Meetup: https://www.meetup.com/Jenkins-online-meetup/events/269459788
* Slides: http://bit.ly/jenkins-gsoc2020-intro

Jeff Thompson outlines the use of find-sec-bugs in Jenkins core and Jenkins plugin development. The find-sec-bugs plugin for spotbugs can help developers detect issues related to security while they are developing.

Jenkins Configuration as Code (JCasC) plugin allows configuring Jenkins instances with declarative YAML files. These files may be quite complex, and hence it is important to have tools which help Jenkins users to create and verify such configuration files. During his Community Bridge project Sladyn Nunes has added a schema generator to the JCasC plugin and created a new Visual Studio Code plugin which provides auto completion and validation for your configuration files.

At this online meetup Sladyn will present his project and demo the new JCasC features he created. What will you learn?
* How to install the JCasC Visual Studio Code Plugin and connect it to your Jenkins Instance
* How to enable auto completion and validation for JCasC YAML files
* How to contribute further if you are interested

References:
- Slides: https://www.slideshare.net/SladynNunes/jenkins-jcasc-online-meetup
- JCasC Plugin for Jenkins: https://plugins.jenkins.io/configuration-as-code/
- JCasC Plugin for Visual Studio Code: https://marketplace.visualstudio.com/items?itemName=jcasc-developers.jcasc-plugin
- Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/268823268/

At the Jenkins Online Meetup on Feb 26 2020 Tim Jacomb presented the new experimental System Read permission which was introduced in Jenkins 2.222. This is a part of the ongoing work to improve experience for Jenkins Configuration-as-Code users.

Slides: https://docs.google.com/presentation/d/167luxwJcETZqP-N3qHgrUt2RcVe9VOnQFpnjtkNxc5c/edit?usp=sharing
JEP-224: https://github.com/jenkinsci/jep/tree/master/jep/224
Meetup page: https://www.meetup.com/Jenkins-online-meetup/

Jenkins Developer Meetup from January 24, 2020 where Oleg Nenashev highlights the use of Dependabot in the Jenkins project. He describes the challenges of dependency management and the ways that Dependabot simplifies those challenges. He also notes places where Jenkins plugin developers should think carefully before applying a dependency update.

Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/267995271/
Slides: https://drive.google.com/file/d/1YbuiqyP1McNuo-Vc3wjpIBOXE3RUTZ-R/view

Steve Terrana present the Jenkins Templating Engine in a Jenkins Online Meetup.

Jenkins Templating Engine allows you to separate the business logic of your pipeline (what should happen, and when) from the technical implementation. Pipeline templates separate the implementation of the pipeline actions defined in the template into pipeline libraries.

Regardless of the specific tools being used, there are common steps that often take place, such as unit testing, static code analysis, packaging, and deploying artifacts to application environments.

Presented at https://www.meetup.com/Jenkins-online-meetup/events/267752823/

Jenkins Developer Meetup discussing recent improvements to the documentation process for plugins and for the jenkins.io documentation site. Improvements include a Wiki exporter tool to assist with migration, GitHub as a documentation source, and release drafter to simplify the creation of accurate, useful, and reliable release notes.

Presented by Oleg Nenashev, Gavin Mogan, and Mark Waite

Ravi Sharma, Martin Krienke, and Larry Ogrodnek presented the POET pipeline framework for Jenkins including the concept of defining each step of the pipeline with a Docker container. Pipelines are defined with a YAML file and use Docker containers referenced in the YAML file to perform their steps.

T-mobile has open sourced the POET pipeline and looks forward to ideas and insights from others.

This year Jenkins project participates in Hacktoberfest: https://jenkins.io/events/hacktoberfest . It is a global 1-month event promoting open-source. Everyone can contribute to open-source projects in October and win some special edition swag.

This Jenkins Online meetup (Oct 03, 2PM UTC, https://zoom.us/j/723056621) opens the Hacktoberfest event in the Jenkins project, and we invite everyone to contribute to the project!

Agenda:

* Oleg Nenashev - Introduction to Hacktoberfest in Jenkins
* Mark Waite - How to Contribute to Jenkins?
* Introductions to featured projects by their maintainers: Jenkins website, Jenkins X, Warnings NG, Configuration-as-Code, Plugin documentation, Jenkins core

Following on from Kohsuke's post 'A new home for Jenkins' to the dev mailing list [1], we have hosted an open forum to discuss the proposal, ask questions and plan the future of the project. Chris Aniszczyk from the Linux Foundation also joined the meeting to talk about the Linux Foundation structure and the CNCF experience.

[1]: Email thread: https://groups.google.com/forum/#!topic/jenkinsci-dev/1w57jl3K4S4
[2]: Slides: https://docs.google.com/presentation/d/1HMJptm6-hJVfaOc5sKc2X8z_1_PuTWcx2YZSSdxLmTs/edit?usp=sharing

Meetup page: https://www.meetup.com/Jenkins-online-meetup/events/258167664/

Meetup details: https://www.meetup.com/Jenkins-online-meetup/events/257773927/

Happy New Year! It's been awhile since our last online meetup. To highlight some of the cool stuff our Jenkins contributors has been working on, we've asked Dr. Ullrich Hafner to share with us his latest project on the next generation warning plugins for Jenkins which is quite impressive as it dramatically improve user experience for static analysis results.

This online meetup is about Eclipse OpenJ9 and Jenkins. The discussion will be led by Steve Poole (Eclipse Openj9), and Tracy Miranda (https://github.com/tracymiranda) where they aim to shed light on some questions:

Eclipse OpenJ9 is a fully open sourced virtual machine designed to run Java applications cost-effectively in the cloud. Jenkins already features significant JVM tuning work to enhance performance. Can Jenkins stand to gain any performance boosts by taking advantage of Eclipse OpenJ9 and its optimizations? How can the two open source communities collaborate to drive improvements for Jenkins running in the cloud?

Q&A | chat on #jenkinsdev Gitter channel.

This Jenkins online meetup talks about our effort to streamline and improve the way major contributions are made to the Jenkins project: Jenkins Enhancement Proposal (JEP) Process. We cover all the What, Why, When, and How of the JEP process: moving from early to discussion, to creating and updating designs, to completed implementation and roll out.

SPEAKERS: Bitwiseman https://github.com/bitwiseman and MarkEWaite https://github.com/MarkEWaite

Slides: https://docs.google.com/presentation/d/1b5nDuoP7Zbp_zYoPjM-XcgYbditzyQdzNGlNx_esmb8/edit?usp=sharing

Slides: https://docs.google.com/presentation/d/1gXkshDLU6MI80j1biL3t9NjFwHatkFwJ8qjw6suzclg/edit

This talk will introduce you to a new open source project, Jenkins X, which is an open source CI / CD platform for Kubernetes based on Jenkins. https://jenkins-x.io/

After a short introduction James will spend most of the talk demonstrating how to develop applications with CI / CD on Kubernetes with Jenkins X:

* easily setup your own CI / CD system on your cloud of choice using standard tools: kubernetes, draft, helm, jenkins
* quickly create new microservices or import existing projects with automated CI / CD
* use Pull Requests to trigger CI, Preview Environments, human approval then a full CD release
* use automated provisioning to Preview, Testing, Staging & Production environments via helm charts and GitOps

After this talk you should be able to develop cloud native apps at full speed with automated CI / CD in any language on any kubernetes cluster! Let's go faster!

About our speaker, James Strachan:
James works on CI + CD for Kubernetes with Jenkins for CloudBees. He's the lead architect of Jenkins X.

He also created the Groovy programming language, Apache Camel & was a founder of fabric8 & ActiveMQ.

(View Slides: https://goo.gl/swxWyb)

Pipeline as code is becoming the standard when it comes to defining jobs in Jenkins. Now we need a similar solution to maintain Jenkins itself.
The Jenkins Configuration as Code Plugin allows us to manage Jenkins and its plugins configuration via human-readable configuration files.

Ewelina (https://github.com/ewelinawilkosz) and Nicolas (https://github.com/ndeloof) will talk about the how the plugin works, the current features, and future plans. They will also discuss how (and why) they work on the plugin and how you can contribute. The session will include with a live demo of the current version of the plugin.


GitHub: https://github.com/jenkinsci/configuration-as-code-plugin

JEP: https://github.com/jenkinsci/jep/blob/master/jep/201/README.adoc

It's been a few months since our last Jenkins Online Meetup (JOM). Many of us have been busy getting ready for Jenkins World which we were able to meet many of you in person...woot woot!

Special thanks to these experts for making time to do a second round of these demos:

Developing Pipeline Libraries Locally: 0:10

Delivery Pipelines with Jenkins: 24:07

Pimp My Blue Ocean: 50:18

Deliver Blue Ocean components at the spead of light: 1:03:30

Mozilla's Declarative + shared libraries setup: 1:21:18

Git Tips & Tricks: 1:47:05

Visual Pipeline Creation in Blue Ocean: 2:03:10

James Dumay will present Blue Ocean; a new user experience for Jenkins based on a personalizable, modern design that allows users to graphically create, visualize and diagnose CD Pipelines. Blue Ocean is more than putting a modern face to Jenkins, it’s a complete revitalization of the way developers use Jenkins that helps them adopt Continuous Delivery. James will take the group through all the new capabilities, tips and tricks that will make Blue Ocean work powerfully for your team.

This meetup is devoted to Pipeline development and will be beneficial to Jenkins users of all levels.

We'll have speakers talking about the new Declarative Pipeline syntax, building basic and advanced Pipelines, and finally a sneak-peek at the new Pipeline Visual Editor from Blue Ocean

We will be concluding our Google Summer of Code (https://jenkins.io/projects/gsoc/) projects with student presentations on their projects