{"id":466,"date":"2024-07-15T00:26:00","date_gmt":"2024-07-15T00:26:00","guid":{"rendered":"https:\/\/blog.ngocha.biz\/?p=466"},"modified":"2024-07-15T00:26:00","modified_gmt":"2024-07-15T00:26:00","slug":"jenkins-architecture-explained","status":"publish","type":"post","link":"https:\/\/blog.ngocha.biz\/?p=466","title":{"rendered":"Jenkins Architecture Explained – Beginners Guide To Jenkins Components"},"content":{"rendered":"

This blog covers the fundamental Jenkins architecture and its related components. If you are a beginner in Jenkins, it will help you understand how Jenkins components work together and the key configurations involved.<\/p>\n

What is Jenkins?<\/h2>\n

Jenkins is an easy-to-use open-source java-based CI\/CD<\/a> tool. It has been around for some time, and several organizations use it for their CI\/CD needs.<\/p>\n

\n
Important Note:<\/strong><\/b> It is essential to have an understanding of Continuous integration & continuous delivery to understand Jenkins better.<\/div>\n<\/div>\n

Jenkins has huge community support and an ocean of plugins that can integrate with many open-source and enterprise tools to make your life so easy.<\/p>\n

Despite the growing popularity of CI\/CD tools like GitLab CI and GitHub Actions, which are increasingly being adopted by organizations for their CI\/CD needs, Jenkins remains widely used in many organizations.<\/p>\n

As per the Developer Ecosystem Report<\/a>, 54% of the developers use Jenkins for CI\/CD.<\/p>\n

\"\"<\/figure>\n

Jenkins is commonly used for the following.<\/p>\n

    \n
  1. Continuous Integration for application and infrastructure code.<\/li>\n
  2. Continuous delivery pipelines to deploy the application to different environments using Jenkins pipeline as code<\/a>.<\/li>\n
  3. Infrastructure component deployment and management using IaC<\/a> Tools..<\/li>\n
  4. Run batch operations using Jenkins jobs.<\/li>\n
  5. Run ad-hoc operations like backups, cleanups, remote script execution, event triggers, etc.<\/li>\n
  6. Jenkins Architecture<\/li>\n<\/ol>\n

    The following diagram shows the overall architecture of Jenkins and the connectivity workflow..<\/p>\n

    \"Jenkins<\/figure>\n

    Following are the key components in Jenkins<\/p>\n

      \n
    1. Jenkins Master Node<\/li>\n
    2. Jenkins Agent Nodes\/Clouds<\/li>\n
    3. Jenkins Web Interface<\/li>\n<\/ol>\n

      Let’s look at each component in detail.<\/p>\n

      Jenkins Server (Formerly Master)<\/h2>\n

      Jenkins’s server or master node holds all key configurations. Jenkins master server is like a control server that orchestrates all the workflow defined in the pipelines. For example, scheduling a job, monitoring the jobs, etc.<\/p>\n

      Let’s have a look at the key Jenkins master components.<\/p>\n

      Jenkins Jobs<\/h3>\n

      A job is a collection of steps that you can use to build your source code, test your code, run a shell script, run an Ansible role in a remote host or execute a terraform play, etc. We normally call it a Jenkins pipeline<\/a>.<\/p>\n

      \"Jenkins<\/figure>\n

      If you translate the above steps to a Jenkins pipeline job, it looks like the following.<\/p>\n

      \"Jenkins<\/figure>\n

      There are multiple job types available to support your workflow for continuous integration & continuous delivery.<\/p>\n

      Jenkins Plugins<\/h3>\n

      Plugins are official and community-developed modules that you can install on your Jenkins server. It helps you with more functionalities that are not natively available in Jenkins.<\/p>\n

      For example, if you want to upload a file to s3 bucket from Jenkins, you can install an AWS Jenkins plugin and use the abstracted plugin functionalities to upload the file rather than writing your own logic in AWS CLI. The plugin takes care of error and exception handling.<\/p>\n

      Here is an example, of s3 file upload functionality provided by the AWS Steps plugin<\/a><\/p>\n

      \"Jenkins<\/figure>\n

      You can install\/upgrade all the available plugins from the Jenkins dashbaord itselft. For corporate network, you will have to setup a proxy details to connect to the plugin repository.<\/p>\n

      You can also download the plugin file and install it by copying it to the plugins directory under \/var\/lib\/jenkins<\/code> folder.<\/p>\n

      You can also develop your custom plugins. Check out all plugins from the Jenkins Plugin Index<\/a><\/p>\n

      Jenkins Global Security<\/h3>\n

      Jenkins has the following type of primary authentication methods.<\/p>\n

        \n
      1. Jenkins’s own user database:-<\/strong> Set of users maintained by Jenkins’s own database. When we say database, its all flat config files (XML files).<\/li>\n
      2. LDAP Integration<\/strong>:- Jenkins authentication using corporate LDAP configuration.<\/li>\n
      3. SAML Single Sign On(SSO)<\/strong>: Support single signon using providers like Okta, AzureAD, Auth0 etc..<\/li>\n<\/ol>\n

        With Jenkins matric-based security you can further assign roles to users on what permission they will have on Jenkins.<\/p>\n

        Jenkins Credentials<\/h3>\n

        When you set up Jenkins pipelines, there are scenarios where it needs to connect to a cloud account, a server, a database, or an API endpoint using secrets.<\/p>\n

        In Jenkins, you can save different types of secrets as a credential.<\/p>\n

          \n
        1. Secret text<\/li>\n
        2. Username & password<\/li>\n
        3. SSH keys<\/li>\n<\/ol>\n

          All credentials are encrypted (AES) by Jenkins. The secrets are stored in $JENKINS_HOME\/secrets\/<\/code> directory. It is very important to secure this directory and exclude it from Jenkins backups.<\/p>\n

          \n
          Note:<\/strong><\/b> Best practice is to use external secrets management solutions like vault<\/a> instead of Jenkins native credentials.<\/div>\n<\/div>\n

          Jenkins Nodes\/Clouds<\/h3>\n

          You can configure multiple agent nodes (Linux\/Windows) or clouds (docker<\/a>, kubernetes) for executing Jenkins jobs. We will learn more about it in the agent section.<\/p>\n

          Jenkins Global Settings (Configure System)<\/h3>\n

          Under Jenkins global configuration, you have all the configurations of installed plugins and native Jenkins global configurations.<\/p>\n

          Also, you can configure global environment variables under this section. For example, you can store the tools (Nexus, Sonarqube, etc) URLs as global environment variables and use them in the pipeline. This way it is easier to make URL changes that get reflected in all the Jenkins jobs.<\/p>\n

          Jenkins Logs<\/h3>\n

          Provides logging information on all Jenkins server actions including job logs, plugin logs, webhook logs, etc.<\/p>\n

          \n
          Note:<\/strong><\/b> All the configurations for the above-mentioned components are present as a config file (XML file) in the Jenkins master nodes data directory.<\/div>\n<\/div>\n

          Jenkins Agent<\/h2>\n

          Jenkins agents are the worker nodes that actually execute all the steps mentioned in a Job. When you create a Jenkins job, you have to assign an agent to it. Every agent has a label as a unique identifier.<\/p>\n

          \"\"<\/figure>\n

          When you trigger a Jenkins job from the master, the actual execution happens on the agent node that is configured in the job.<\/p>\n

          \n
          Note:<\/strong><\/b> You can run jobs in the Jenkins server without a Jenkins agent. In this case, master nodes acts as the agent. However, the recommended approach is to have a Jenkins master-agent setup<\/a> for different job requirements so that you don’t end up corrupting the Jenkins server for any system-wide configuration changes required for a job.<\/div>\n<\/div>\n

          You can have any number of Jenkins agents attached to a master with a combination of Windows, Linux servers, and even containers as build agents.<\/p>\n

          Also, you can restrict jobs to run on specific agents, depending on the use case. For example, if you have an agent with java 8 configurations, you can assign this agent for jobs that require Java 8 environment.<\/p>\n

          There is no single standard for using the agents. You can set up a workflow and strategy based on your project needs.<\/p>\n

          Jenkins server-agent Connectivity<\/h2>\n

          You can connect a Jenkins master and agent in two ways<\/p>\n

            \n
          1. Using the SSH method:<\/strong> Uses the ssh protocol to connect to the agent. The connection gets initiated from the Jenkins master. Ther should be connectivity over port 22 between master and agent.<\/li>\n
          2. Using the JNLP method:<\/strong> Uses java JNLP protocol (Java Network Launch Protoco<\/a>l). In this method, a java agent gets initiated from the agent with Jenkins master details. For this, the master nodes firewall should allow connectivity on specified JNLP port. Typically the port assigned will be 50000<\/code>. This value is configurable.<\/li>\n<\/ol>\n

            There are two types of Jenkins agents<\/p>\n

              \n
            1. Agent Nodes:<\/strong> These are servers (Windows\/Linux) that will be configured as static agents<\/a>. These agents will be up and running all the time and stay connected to the Jenkins server. Organizations use custom scripts to shut down and restart the agents when is not used. Typically during nights & weekends.<\/li>\n
            2. Agent Clouds:<\/strong> Jenkins Cloud agent is a concept of having dynamic agents<\/a>. Means, whenever you trigger a job, a agent gets deployed as a VM\/container on demand and gets deleted once the job is completed. This method saves money in terms of infra cost when you have a huge Jenkins ecosystem and continuous builds.<\/li>\n<\/ol>\n

              The following image shows a high-level view of different types of agents and connectivity types.<\/p>\n

              \"\"<\/figure>\n

              You can refer to the following tutorials to understand more about Jenkins clouds.<\/p>\n

                \n
              1. Docker container as build agents.<\/a><\/li>\n
              2. Setup Jenkins Build Agents on Kubernetes Pods<\/a><\/li>\n<\/ol>\n

                Jenkins Data<\/h2>\n

                All the Jenkins data gets stored in the following folder location.<\/p>\n

                \n
                \/var\/lib\/jenkins\/<\/div>\n<\/div>\n

                Data includes all jobs config files, plugins configs, secrets, node information, etc. It makes Jenkins migration very easy as compared to other tools.<\/p>\n

                If you take a jook at \/var\/lib\/jenkins\/ you will find most of the configurations in xml format.<\/p>\n

                It is essential to back up the Jenkins data<\/a> folder every day. For some reason, if your Jenkins server data gets corrupt, you can restore the whole Jenkins with the data backup.<\/p>\n

                Ideally, when deploying Jenkins in production, a dedicated extra volume is attached<\/strong> to the Jenkins servers that hold all the Jenkins data.<\/p>\n

                \"\"<\/figure>\n

                Jenkins Web Interface<\/h2>\n

                Jenkins 2.0<\/a> introduced a very intuitive web interface called “Jenkins Blue Ocean<\/strong>“. It has a good visual representation of all the pipelines.<\/p>\n

                \"Jenkins<\/figure>\n

                Conclusion<\/h2>\n

                In this blog, I have explained Jenkins architecture and its key components.<\/p>\n

                I personally like Jenkins for its huge community support, its extensive official and community documentation.<\/p>\n

                I have written many Jenkins tutorials<\/a> from my experience. If you are pursuing a career as a DevOps engineer<\/a>, this is one of the best DevOps tools to learn hands-on CI\/CD.<\/p>\n

                You might be starting to learn Jenkins or have some doubts regarding its workflow.<\/p>\n

                Either way drop a comment below.<\/p>\n

                And if you want to learn about how GitLab handles CI\/CD internally, check out my detailed guide on GitLab Architecture.<\/a><\/p>\n

                \n

                Ngu\u1ed3n:<\/strong> Jenkins Architecture Explained – Beginners Guide To Jenkins Components \u2014 DevOpsCube<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

                Source: https:\/\/devopscube.com\/jenkins-architecture-explained\/<\/p>\n","protected":false},"author":1,"featured_media":467,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-466","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-devops"],"_links":{"self":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts\/466","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=466"}],"version-history":[{"count":0,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts\/466\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/media\/467"}],"wp:attachment":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=466"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=466"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=466"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}