GNU/Linux >> Tutoriales Linux >  >> Ubuntu

Cómo instalar Jenkins en el último Ubuntu en 5 minutos

Este artículo cubre varias formas de implementar Jenkins en su servidor. Utilice nuestra guía actualizada para la instalación manual o el lanzamiento de Jenkins en contenedores Docker. Como beneficio adicional, le mostraremos cómo implementar Jenkins usando CloudFormation. Implemente Jenkins en su servidor en 5 minutos siguiendo nuestra guía.

Que es Jenkins

Jenkins es el servidor de automatización gratuito más popular. Puede usar Jenkins para automatizar casi cualquier proceso en su empresa. Pero el mercado tradicional de Jenkins es la automatización de los procesos de desarrollo de software.

Beneficios de Jenkins:

  • Escrito en Java, por lo que puede ejecutarlo en todas las plataformas
  • Tiene muchos complementos, que pueden ayudarlo a resolver casi cualquier problema que pueda imaginar.
  • Ayuda a los desarrolladores a integrar los cambios de código y producir siempre una compilación de software estable

Instalar Jenkins manualmente

El proceso de instalación es simple y directo. Consta de varios pasos sencillos:

  • Instalación de Java.
  • Agregar repositorios oficiales de Jenkins a su administrador de paquetes.
  • Instalación del paquete.
  • Configuración del cortafuegos.
  • Configuración inicial de Jenkins.

Hagámoslos uno por uno.

Instalación de Java

Para poder ejecutar Jenkins, primero debe instalar Java.

Primero, actualice el índice del paquete apt usando esto:

$ sudo apt update

A continuación, instale el paquete Java OpenJDK predeterminado usando esto:

$ sudo apt install openjdk-8-jre

Verifique la instalación usando este comando:

$ java -version

Aquí está el resultado después de una instalación exitosa:

Importante :debería ver que Java tiene la versión 1.8.

Al momento de escribir este artículo, Jenkins está usando la versión Java 8. Si ve otra versión, cambie a la correcta:

$ sudo update-alternatives --config java

Añadir repositorio de Jenkins

De manera predeterminada, Jenkins no está incluido en los repositorios de Ubuntu y debe agregarlo.

Primero, necesitamos importar la clave del repositorio:

$ wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -

El siguiente paso es agregar la dirección del repositorio a la lista de repositorios del servidor:

$ sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > \
    /etc/apt/sources.list.d/jenkins.list'

Una vez hecho esto, necesitamos actualizar la información sobre el software, que podemos usar desde el nuevo repositorio:

$ sudo apt-get update

Instalación del paquete Jenkins

Ya que tenemos el repositorio actualizado, ejecutemos el siguiente comando:

$ sudo apt-get -y install jenkins

Ejecutar este comando le pedirá que confirme la descarga y la instalación.

De forma predeterminada, Jenkins se inicia después del proceso de instalación. Si no, usa el siguiente comando para hacerlo manualmente:

$ sudo systemctl start jenkins

Vamos a comprobar si el estado del servicio de Jenkins:

$ sudo systemctl status jenkins

En la ejecución exitosa del comando anterior, debería obtener tal resultado:

Configuración del cortafuegos

De forma predeterminada, Jenkins se ejecuta en el puerto 8080 , así que abrámoslo para permitir que Jenkins se comunique.

Ejecute el siguiente comando si está ejecutando el firewall UFW predeterminado:

$ sudo ufw allow 8080

Utilice el siguiente comando para comprobar que ahora se permite el tráfico:

$ sudo ufw status

La salida del comando anterior debería verse así:

Si ufw está inactivo y desea habilitarlo, estos son los comandos:

$ sudo systemctl enable ufw

$ sudo systemctl start ufw

$ sudo ufw enable

Ahora puede acceder a Jenkins en http://localhost:8080 .

La contraseña inicial está disponible aquí:

$ sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Iniciar Jenkins en Docker Container

Para iniciar Jenkins en un contenedor Docker, debe tener Docker instalado. El proceso de instalación completo se describe en la documentación oficial de Docker, por lo que proporcionaremos los comandos necesarios aquí:

$ sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common


$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

$ sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"
$ sudo apt-get update

$ sudo apt-get install docker-ce docker-ce-cli containerd.io

Una vez que Docker se haya instalado correctamente, puede ejecutar el contenedor de Docker.

Extraer imagen acoplable de Jenkins

Extraiga Jenkins del repositorio público con el siguiente comando:

$ sudo docker pull jenkins/jenkins

Para iniciar el contenedor Jenkins Docker, ejecute el siguiente comando:

$ sudo docker run -p 8080:8080 -d --name=jenkins-master jenkins/jenkins

Si recibe el siguiente mensaje de error:

docker: Error response from daemon: driver failed programming external connectivity on endpoint jenkins-master
(627574f0c75a8e4598abf0acfc2700caf53775a9dc34073fdbfb69cd408a9a36):
Error starting userland proxy: listen tcp 0.0.0.0:8080: bind: address already in use.
ERRO[0000] error waiting for container: context canceled

Eso significa que está tratando de iniciar Jenkins en el contenedor Docker en el mismo puerto que está usando Jenkins en todo el sistema.

Solo ejecútalo en el puerto 8082 :

$ sudo docker rm jenkins-master

$ sudo docker run -p 8082:8080 -d --name=jenkins-master jenkins/jenkins

Este comando da como resultado la apertura del contenedor acoplable de Jenkins en el puerto 8082 :

Configuración inicial de Jenkins

Para configurar Jenkins, abra un navegador y navegue hasta la dirección IP real o el nombre de dominio en el que está ejecutando Jenkins:http://ip_address_or_domain:8080 .

Contraseña de Jenkins

Verá la página que muestra la ubicación de la contraseña inicial de Jenkins:

Aquí está:

$ sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Complementos de Jenkins

En la siguiente pantalla, se le pedirá que elija complementos para la instalación inicial. Si aún no sabe qué complementos configurar, use la opción "Instalar complementos sugeridos " opción.

Usuario administrador de Jenkins

Una vez que se complete la instalación, se le pedirá que cree el primer usuario administrador de Jenkins.

Después de ingresar correctamente los detalles del usuario, se le dirigirá a la página de configuración de la instancia para confirmar la URL de la instancia de Jenkins.

Para acceder al panel principal de Jenkins, haga clic en "Empezar a usar Jenkins " botón. Esta acción lo llevará a la interfaz principal de Jenkins:

Instalar Jenkins usando CloudFormation

El artículo "Tutorial de CloudFormation:cómo automatizar la instancia EC2 en 5 minutos" describe cómo usar CloudFormation y los metadatos de inicio de nube para automatizar la instalación de software en instancias EC2.

Aquí proporcionaremos una plantilla, que implementará el servidor Jenkins detrás del servidor proxy Nginx.

Atención :la siguiente plantilla de CloudFormation creará un servidor Jenkins en una subred de VPC pública, que tiene acceso ilimitado a su cuenta de AWS. Si desea restringir el acceso de Jenkins, modifique JenkinsPolicy o el perfil de instancia remota desde el servidor de Jenkins.

Aquí está la plantilla de CloudFormation (fuentes de GitHub):

AWSTemplateFormatVersion: 2010-09-09
Description: >-
    This CloudFormation stack will deploy Jenkins on Ubuntu 20.04
    in us-east-1 region.    
Parameters:
    JenkinsInstanceType:
        Description: EC2 instance type for Jenkins EC2 instance
        Type: String
        Default: t2.small
        ConstraintDescription: must be a valid Jenkins EC2 instance type.
    KeyName:
        Description: >-
                        The EC2 Key Pair to allow SSH access to Jenkins EC2 instance
        Type: 'AWS::EC2::KeyPair::KeyName'
        ConstraintDescription: must be the name of an existing EC2 KeyPair.
    VpcId:
        Description: The VPC Id where the Jenkins EC2 instance will be launched.
        Type: 'AWS::EC2::VPC::Id'
        ConstraintDescription: must be the ID of an existing VPC.
    YourIPRange:
        Description: >-
            CIDR block of the network from where you will connect to the Jenkins
            server using HTTP, HTTPS and SSH            
        Type: String
        MinLength: '9'
        MaxLength: '18'
        AllowedPattern: '(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/(\d{1,2})'
        Default: 0.0.0.0/0
        ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
    PublicSubnet1:
        Description: >-
                        The public subnet where the Jenkins Jenkins EC2 instance will be launched.
        Type: 'AWS::EC2::Subnet::Id'
        ConstraintDescription: Must be a valid Public VPC Subnet.
    JenkinsInstanceAMI:
        Description: Ubuntu 20.04 EC2 instance AMI
        Type: String
        Default: ami-0885b1f6bd170450c

Resources:
    JenkinsAddress:
        Type: AWS::EC2::EIP
        Properties:
            Domain: vpc
    JenkinsAddressAssociaation:
        Type: AWS::EC2::EIPAssociation
        Properties:
            AllocationId: !GetAtt JenkinsAddress.AllocationId
            NetworkInterfaceId: !Ref JenkinsInterface
    JenkinsInterface:
        Type: AWS::EC2::NetworkInterface
        Properties:
            SubnetId: !Ref PublicSubnet1
            Description: Interface for controlling traffic such as Web
            GroupSet: 
                - !Ref JenkinsSecurityGroup
            SourceDestCheck: true
            Tags:
                -
                    Key: Network
                    Value: Web
    JenkinsServer:
        Type: 'AWS::EC2::Instance'
        CreationPolicy:
           ResourceSignal:
               Timeout: PT15M
        Metadata:
            Comment: 'Install Jenkins, nginx and the Jenkins CodeDeploy plugin'
            'AWS::CloudFormation::Init':
                configSets:
                    install_all:
                        - install_base
                        - install_nginx
                        - install_jenkins_repo
                        - install_jenkins
                        - jenkins_post_install
                install_base:
                    packages:
                        apt:
                            git: []
                            python3-pip: []
                            awscli: []
                    files:
                        /etc/cfn/cfn-hup.conf:
                            content:
                                !Sub |
                                    [main]
                                    stack=${AWS::StackName}
                                    region=${AWS::Region}
                            mode: "000400"
                            owner: "root"
                            group: "root"
                        /etc/cfn/hooks.d/cfn-auto-reloader.conf:
                            content:
                                !Sub |
                                    [cfn-auto-reloader-hook]
                                    triggers=post.update
                                    path=Resources.LaunchConfig.Metadata.AWS::CloudFormation::Init
                                    action=/opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource JenkinsServer --configsets install_all --region ${AWS::Region}
                                    runas=root
                            mode: "000400"
                            owner: "root"
                            group: "root"
                        /lib/systemd/system/cfn-hup.service:
                            content:
                                !Sub |
                                    [Unit]
                                    Description=cfn-hup daemon

                                    [Service]
                                    Type=simple
                                    ExecStart=/opt/aws/bin/cfn-hup
                                    Restart=always

                                    [Install]
                                    WantedBy=multi-user.target
                            mode: "000400"
                            owner: "root"
                            group: "root"
                    commands:
                        01_enable_cfn_hup:
                            command: systemctl enable cfn-hup.service > /dev/null 2>&1
                        02_start_cfn_hup:
                            command: systemctl start cfn-hup.service > /dev/null 2>&1

                install_nginx:
                    packages:
                        apt:
                            nginx: []
                            certbot: []
                            python3-certbot-nginx: []
                    files:
                        /etc/nginx/nginx.conf:
                            content:
                                !Sub |
                                    user  www-data;
                                    worker_processes  1;

                                    error_log  /var/log/nginx/error.log;
                                    pid        /var/run/nginx.pid;

                                    events {
                                        worker_connections  1024;
                                    }

                                    http {
                                        include       /etc/nginx/mime.types;
                                        default_type  application/octet-stream;
                                        log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                                                            '$status $body_bytes_sent "$http_referer" '
                                                            '"$http_user_agent" "$http_x_forwarded_for"';

                                        access_log  /var/log/nginx/access.log  main;
                                        sendfile        on;
                                        keepalive_timeout  65;
                                        include /etc/nginx/conf.d/*.conf;
                                        index   index.html index.htm;

                                        server {
                                            listen       80;
                                            server_name  _;
                                            location / {
                                                proxy_pass              http://127.0.0.1:8080;
                                                proxy_set_header        Host $host;
                                                proxy_set_header        X-Real-IP $remote_addr;
                                                proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
                                                proxy_connect_timeout   150;
                                                proxy_send_timeout      100;
                                                proxy_read_timeout      100;
                                                proxy_buffers           4 32k;
                                                client_max_body_size    8m;
                                                client_body_buffer_size 128k;
                                            }
                                            location /password.txt {
                                                alias              /web/initalpass.html;
                                            }
                                        }
                                    }
                            mode: '000644'
                            owner: root
                            group: root

                    services:
                        sysvinit:
                            nginx:
                                enabled: 'true'
                                ensureRunning: 'true'
                                files:
                                    - /etc/nginx/nginx.conf

                install_jenkins_repo:
                    commands:
                        01_download_repo_file:
                            command: echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list
                        02_import_repo_file:
                            command: wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | apt-key add - > /dev/null 2>&1
                        03_update_pkg_mngr:
                            command: apt-get update -y > /dev/null 2>&1

                install_jenkins:
                    packages:
                        apt:
                            jenkins: []
                    services:
                        sysvinit:
                            jenkins:
                                enabled: 'true'
                                ensureRunning: 'true'

                jenkins_post_install:
                    commands:
                        01_web_folder:
                            command: mkdir -p /web
                        02_import_repo_file:
                            command: while [ ! -f /var/lib/jenkins/secrets/initialAdminPassword ]; do sleep 10; done
                        03_copy_jenkins_password:
                            command: cp -Rf /var/lib/jenkins/secrets/initialAdminPassword /web/initalpass.html && chown www-data:www-data /web/initalpass.html
        Properties:
            KeyName: !Ref KeyName
            ImageId: !Ref JenkinsInstanceAMI
            NetworkInterfaces:
                -
                    NetworkInterfaceId: !Ref JenkinsInterface
                    DeviceIndex: '0'
            InstanceType: !Ref JenkinsInstanceType
            IamInstanceProfile: !Ref JenkinsInstanceProfile
            UserData:
                Fn::Base64:
                    !Sub |
                        #!/bin/bash -xe

                        apt-get update -y
                        apt-get install -y python-setuptools openjdk-8-jre
                        mkdir -p /opt/aws/bin
                        wget https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-latest.tar.gz
                        python2 -m easy_install --script-dir /opt/aws/bin aws-cfn-bootstrap-latest.tar.gz

                        echo "Executing config-sets"

                        /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} \
                            --resource JenkinsServer \
                            --configsets install_all \
                            --region ${AWS::Region}

                        /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} \
                            --resource JenkinsServer \
                            --region ${AWS::Region}
            Tags:
                -
                    Key: Name
                    Value: Jenkins Server

    JenkinsSecurityGroup:
        Type: 'AWS::EC2::SecurityGroup'
        Properties:
            GroupDescription: Enable SSH and HTTP access from specific CIDR block
            VpcId: !Ref VpcId
            SecurityGroupIngress:
                    -
                        IpProtocol: tcp
                        FromPort: 22
                        ToPort: 22
                        CidrIp: !Ref YourIPRange
                    -
                        IpProtocol: tcp
                        FromPort: 80
                        ToPort: 80
                        CidrIp: !Ref YourIPRange
                    -
                        IpProtocol: tcp
                        FromPort: 443
                        ToPort: 443
                        CidrIp: !Ref YourIPRange
            SecurityGroupEgress:
                    -
                        IpProtocol: tcp
                        FromPort: 0
                        ToPort: 65535
                        CidrIp: 0.0.0.0/0

    JenkinsRole:
        Type: 'AWS::IAM::Role'
        Properties:
            Path: /
            AssumeRolePolicyDocument:
                Statement:
                    -
                        Effect: Allow
                        Principal:
                            Service:
                                - ec2.amazonaws.com
                        Action:
                            - 'sts:AssumeRole'

    JenkinsInstanceProfile:
        Type: 'AWS::IAM::InstanceProfile'
        Properties:
            Path: /
            Roles:
                - !Ref JenkinsRole

    JenkinsPolicy:
        Type: 'AWS::IAM::Policy'
        Properties:
            PolicyName: JenkinsPolicy
            PolicyDocument:
                Version: 2012-10-17
                Statement:
                    -
                        Effect: Allow
                        Action:
                            - '*'
                        Resource: '*'
            Roles:
                - !Ref JenkinsRole

Outputs:
    JenkinsServerDNSName:
        Description: DNS Name of Jenkins Server
        Value: !GetAtt
            - JenkinsServer
            - PublicDnsName

Esta plantilla de CloudFormation es para implementar Jenkins detrás del proxy Nginx en su infraestructura de AWS.

Esta plantilla tiene las siguientes características:

  • Tienes que curl para obtener la contraseña inicial de Jenkins: curl http://ec2-host/contraseña.txt .
  • Puede usar LetsEncrypt para crear certificados SSL: sudo certbot --nginx -d jenkins.example.com .

Resumen

En este artículo, cubrimos varias formas de implementar Jenkins en su servidor. Ahora está listo para la instalación manual de Jenkins, el lanzamiento de Jenkins en el contenedor Docker o la implementación de Jenkins mediante la plantilla de CloudFormation.

Por favor, háganos saber en la sección de comentarios a continuación si tiene alguna pregunta. Además, le recomendamos que consulte otros artículos relacionados con Linux en nuestro blog.

¡Esperamos que encuentre útil este artículo! Si es así, ¡ayúdanos a difundirlo por todo el mundo!


Ubuntu
  1. Cómo instalar la última versión de Kodi en Ubuntu

  2. Cómo instalar la última versión de Handbrake en Ubuntu

  3. Cómo instalar la última versión de desarrollo de GIMP 2.9 en Ubuntu

  4. Cómo instalar el último PipeWire a través de PPA en Ubuntu 20.04, 21.04

  5. Cómo instalar el último KeePassXC 2.7.0 en Ubuntu 22.04 a través de PPA

Cómo instalar la última versión de WildFly en Ubuntu 20.04

Cómo instalar la última versión de MySQL 8 en Ubuntu 20.04

¿Cómo instalar la última versión de GCC en Ubuntu 20.04?

Cómo instalar el último PHPMyAdmin en Ubuntu 18.04

Cómo instalar Jenkins en Ubuntu 14.04

Cómo instalar la última versión de ImageMagick en Ubuntu 22.04