Jenkins overview

Author: llpeterson

dict.txt

@@ -71,6 +71,7 @@ Tofino
 Vemuri
 VM
 VMware
+Weaveworks
 
 adaptor
 adaptors

intro.rst

@@ -255,8 +255,7 @@ bundled and purpose-built network appliances that came before, and so
 from the management perspective, it is helpful to identify what
 becomes easier and what becomes harder when you make this
 transition. This is both the challenge and the opportunity of
-disaggregation. (For a brief introduction to disagggregation and the
-trend to cloud native designs, so the
+disaggregation.
 
 Broadly speaking, disaggregation is the process of breaking large
 bundled components into a set of smaller constituent parts. SDN is one

lifecycle.rst

@@ -387,8 +387,45 @@ different build tools for their individual projects (which we've been
 referring to in generic terms as subsystems), and we will employ a
 simple second-level tool to integrate the output of all those
 sophisticated first-level tools. Our choice for the second-level tool
-is Jenkins, which provides little more than a means to define a script
-(called a job) to run in response to some event.
+is Jenkins, which provides little more than a means to define a
+sequence of scripts to run in response to some event (such as a patch
+being checked into the Code Repo).
+
+.. _reading_jenkins:
+.. admonition:: Further Reading
+
+   `Jenkins <https://www.jenkins.io/doc/>`__.
+
+Like many of the tools described in this book, Jenkins has a graphical
+dashboard that can be used to create, execute, and view the results of
+a set of jobs, but this is mostly useful for toy examples. Because
+Jenkins plays a central role in our CI pipeline, it is managed like
+all the other components we are building—via a declarative
+specification file. This file, called a *Jenkinsfile*, is then checked
+into the repo just like all the other configuration-as-code files, and
+in yet another example of the recursive nature of Lifecycle
+Management, manages the Jenkins CI service.
+
+In many ways, Jenkins lets you do anything you want since it is
+fundamentally a mechanism that executes shell scripts.  When used in a
+disciplined way, however, Jenkins provides a means to define a
+*Pipeline* consisting of a sequence of *Stages*. Each stage then
+executes some script and tests whether the script succeed or
+failed. In principle then, Jenkins could be the centerpiece of the
+entire CI/CD pipeline since one could define a "Build" stage, followed
+by a "Test" stage, and then conditional upon success, conclude with a
+"Deploy" stage. In practice, however, Jenkins is used more narrowly to
+build-and-test individual components; integrate-and-test various
+combinations of components; and under limited circumstances, includes
+a "Publish" stage that copies an artifact that's just been built
+(e.g., a Docker Image) to the Image Repo.
+
+The main challenge in using Jenkins is establishing a suitable set of
+environments for running tests, which we discussed briefly in Section
+4.2. Environments can be built from scratch (which takes time but
+validates end-to-end integration), or use pre-built containers or VMs
+(which is more expedient but risks missing regressions in the
+software). No amount of tooling resolves this fundamental trade-off.
 
 4.4 Continuous Deployment
 -------------------------