Jenkins on Joonlog

컨테이너 환경에서 Jenkins의 PHP CICD 파이프라인 구축하기

Thu, 20 Nov 2025 09:00:00 +0900

PHP 애플리케이션에 대한 CI/CD 파이프라인 설정 방법

환경

Git 리포지토리 및 컨테이너 레지스트리: GitLab
CI/CD: Jenkins
PHP 버전: 8.3
파이프라인을 컨테이너에서 동작시키기 위한 Jenkins Agent 도커 설정

파이프라인 설정

Git 리포지토리 연동
- Definition: Pipeline script from SCM
  - 파이프라인 구성에 필요한 스크립트를 SCM에서 가져오도록 설정
- SCM: Git
- Repository URL: Git 리포지토리 URL
- Credentials: Git 리포지토리에 접근 가능하도록 저장한 Credential
- Branch Specifier: */main

CI 파이프라인

컨테이너 이미지를 빌드하기 위한 Dockerfile도 Git 리포지토리에 있어야 함
PHP는 빌드 과정이 필요 없는 인터프리터 언어이기 때문에 소스 빌드 없이 이미지 빌드 → 이미지 푸시 과정만 필요
CI 완료 전 CD 파이프라인을 트리거

1. 환경

agent any로 jenkins agent 컨테이너를 파이프라인으로 사용

1
2
3
4
5
6
7
8
9


pipeline {
 agent any

 environment {
 APP_NAME = '<애플리케이션 명>'
 GITLAB_REGISTRY = '<컨테이너 레지스트리 URL>'
 GITLAB_PROJECT = '<Git 리포지토리 명>'
 GITLAB_CREDENTIAL_ID = '<저장한 Git PAT 토큰 ID>'
 }

2. Git 체크아웃

Git 리포지토리의 최신 커밋을 체크아웃
파이프라인 로그에 커밋 정보 출력

1
2
3
4
5
6
7


 stages {
 stage('Checkout') {
 steps {
 checkout scm
 sh 'git log -1 --oneline'
 }
 }

3. 컨테이너 이미지 빌드 및 레지스트리 푸시

Git 리포지토리에 있는 Dockerfile을 기반으로 이미지 빌드
Git 커밋 해시와 Jenkins 빌드 번호를 조합해서 태그 생성
GitLab PAT 토큰으로 로그인 후 푸시

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


 stage('Docker Build & Push') {
 steps {
 script {
 def gitCommit = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()
 def imageTag = "${env.BUILD_NUMBER}-${gitCommit}"
 def fullImage = "${GITLAB_REGISTRY}/${GITLAB_PROJECT}/${APP_NAME}"

 sh """
 docker build --no-cache -t ${fullImage}:${imageTag} .
 docker tag ${fullImage}:${imageTag} ${fullImage}:latest
 """

 withCredentials([usernamePassword(credentialsId: "${GITLAB_CREDENTIAL_ID}",
 usernameVariable: 'GITLAB_USER',
 passwordVariable: 'GITLAB_TOKEN')]) {
 sh """
 echo "\$GITLAB_TOKEN" | docker login ${GITLAB_REGISTRY} -u "\$GITLAB_USER" --password-stdin
 docker push ${fullImage}:${imageTag}
 docker push ${fullImage}:latest
 docker logout ${GITLAB_REGISTRY}
 """
 }

 echo "Docker image pushed: ${fullImage}:${imageTag}"
 echo "Docker image pushed: ${fullImage}:latest"
 }
 }

4. CD 파이프라인 트리거

CI 파이프라인이 완료 되기 전 CD 파이프라인을 동작하도록 트리거

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


 stage('Trigger CD') {
 steps {
 build job: '<CD 파이프라인 이름>',
 parameters: [
 string(name: 'IMAGE_TAG', value: 'latest'),
 string(name: 'DEPLOY_TARGET', value: 'ALL')
 ],
 wait: true, // CD 끝날 때까지 기다릴지
 propagate: true // CD 실패하면 이 Job도 실패로 처리할지
 }
 }
 }

5. 파이프라인 결과 체크

1
2
3
4
5
6
7
8
9


 post {
 success {
 echo "Build #${env.BUILD_NUMBER} succeeded for ${APP_NAME}"
 }
 failure {
 echo "Build #${env.BUILD_NUMBER} failed - check console output"
 }
 }
}

CD 파이프라인

Jenkins 서버에서 배포할 서버에 SSH로 접근 후 docker compose 파일을 기동하여 컨테이너 레지스트리의 이미지를 가져오는 방식으로 배포
배포할 서버가 여러 개일 경우를 고려해서 구성

환경

agent any로 jenkins agent 컨테이너를 파이프라인으로 사용
DB 접속정보 등 민감한 정보가 있는 .env 파일은 Jenkins Credential로 관리

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


pipeline {
 agent any

 parameters {
 string(name: 'IMAGE_TAG', defaultValue: 'latest', description: 'Docker image tag to deploy')
 choice(name: 'DEPLOY_TARGET', choices: ['WAS1', 'ALL'], description: 'WAS1: <WAS 서버 IP> | ALL: 전체 WAS 배포')
 }

 environment {
 WAS1_HOST = '<WAS1 서버 IP>'
 // WAS2_HOST = '<WAS2 서버 IP>' // TODO: WAS2 추가 시 활성화
 DEPLOY_PATH = '<배포 경로>'
 GITLAB_REGISTRY = '<컨테이너 레지스트리 URL>'
 GITLAB_PROJECT = '<Git 리포지토리명>'
 IMAGE_NAME = '<컨테이너 이미지 명>'
 DEPLOY_CREDENTIAL_ID = '<배포 서버 SSH 계정명>'
 GITLAB_CREDENTIAL_ID = '<저장한 Git PAT 토큰 ID>'
 TEACHER_ENV_FILE_CREDENTIAL_ID = '<Credential에 저장한 .env 파일 ID>'
 COMPOSE_FILE_LOCAL = 'docker-compose.yaml'
 }

1. Git 체크아웃

파이프라인이 “Pipeline script from SCM” 으로 되어 있기 때문에 가능
docker-compose.yaml 파일을 가져오기 위함

1
2
3
4
5
6
7


 stage('Checkout') {
 steps {
 // CD Job이 Pipeline from SCM로 설정돼 있다는 전제
 checkout scm
 sh "ls -al ${COMPOSE_FILE_LOCAL} || echo 'compose 파일 경로 확인 필요'"
 }
 }

2. 준비

배포할 이미지 태그 / 배포 대상 서버를 선택할 수 있게 설정
deployHosts: 배포 대상 호스트 목록

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


 stages {
 stage('Prepare') {
 steps {
 script {
 echo "Deploying image: ${GITLAB_REGISTRY}/${GITLAB_PROJECT}/${IMAGE_NAME}:${params.IMAGE_TAG}"
 echo "Deploy target: ${params.DEPLOY_TARGET}"

 def deployHosts = []
 if (params.DEPLOY_TARGET == 'WAS1') {
 deployHosts = [WAS1_HOST]
 } else if (params.DEPLOY_TARGET == 'ALL') {
 deployHosts = [WAS1_HOST]
 // TODO: WAS2 추가 시 -> deployHosts = [WAS1_HOST, WAS2_HOST]
 }

 env.DEPLOY_HOSTS = deployHosts.join(',')
 echo "Target servers: ${env.DEPLOY_HOSTS}"
 }
 }
 }

3. 배포

컨테이너 레지스트리에서 이미지 풀링
.env 파일을 Credential에서 배포 서버로 복사
git으로 체크아웃한 docker-compose 파일을 배포 서버로 복사
배포 경로에서 docker compose 명령어를 통한 애플리케이션 재기동

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


 stage('Deploy') {
 steps {
 script {
 def hosts = env.DEPLOY_HOSTS.split(',')

 withCredentials([
 usernamePassword(credentialsId: "${DEPLOY_CREDENTIAL_ID}",
 usernameVariable: 'DEPLOY_USER',
 passwordVariable: 'DEPLOY_PASS'),
 usernamePassword(credentialsId: "${GITLAB_CREDENTIAL_ID}",
 usernameVariable: 'GITLAB_USER',
 passwordVariable: 'GITLAB_TOKEN'),
 // .env 전체를 파일로 받음
 file(credentialsId: "${TEACHER_ENV_FILE_CREDENTIAL_ID}",
 variable: '<env 변수명>')
 ]) {
 for (host in hosts) {
 echo "Deploying to ${host}..."

 sh """
 # 0) 임시 파일 경로(충돌 방지용)
 TMP_ENV=/tmp/env.\$(date +%s)
 TMP_COMPOSE=/tmp/compose.\$(date +%s).yaml

 # 1) .env / docker-compose.yaml 둘 다 /tmp 로 복사
 sshpass -p "\$DEPLOY_PASS" scp -o StrictHostKeyChecking=no "\$<env 변수명>" "\$DEPLOY_USER"@${host}:"\$TMP_ENV"

 sshpass -p "\$DEPLOY_PASS" scp -o StrictHostKeyChecking=no "${COMPOSE_FILE_LOCAL}" "\$DEPLOY_USER"@${host}:"\$TMP_COMPOSE"

 # 2) 서버 안에서 sudo로 최종 위치로 이동 + 권한 조정 + 컨테이너 재기동
 sshpass -p "\$DEPLOY_PASS" ssh -o StrictHostKeyChecking=no "\$DEPLOY_USER"@${host} "
 echo 'Apply .env & docker-compose.yaml...'

 # .env 교체
 sudo mv \$TMP_ENV ${DEPLOY_PATH}/.env
 sudo chown nginx:nginx ${DEPLOY_PATH}/.env

 # docker-compose.yaml 교체
 sudo mv \$TMP_COMPOSE ${DEPLOY_PATH}/docker-compose.yaml
 sudo chown root:root ${DEPLOY_PATH}/docker-compose.yaml

 echo 'Logging in to GitLab Registry...'
 echo '\$GITLAB_TOKEN' | sudo docker login ${GITLAB_REGISTRY} -u '\$GITLAB_USER' --password-stdin

 echo 'Pulling image: ${GITLAB_REGISTRY}/${GITLAB_PROJECT}/${IMAGE_NAME}:${params.IMAGE_TAG}'
 sudo docker pull ${GITLAB_REGISTRY}/${GITLAB_PROJECT}/${IMAGE_NAME}:${params.IMAGE_TAG}

 echo 'Redeploying containers...'
 export IMAGE_TAG=${params.IMAGE_TAG}

 sudo docker compose -f ${DEPLOY_PATH}/docker-compose.yaml down
 sudo docker compose -f ${DEPLOY_PATH}/docker-compose.yaml up -d

 sudo docker logout ${GITLAB_REGISTRY}
 "
 """

 echo "Deployment to ${host} completed."
 }
 }
 }
 }
 }

4. 헬스 체크

배포 완료 후 컨테이너 상태 점검

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


 stage('Health Check') {
 steps {
 script {
 echo "Waiting for application to start..."
 sleep 10

 def hosts = env.DEPLOY_HOSTS.split(',')

 withCredentials([
 usernamePassword(credentialsId: "${DEPLOY_CREDENTIAL_ID}",
 usernameVariable: 'DEPLOY_USER',
 passwordVariable: 'DEPLOY_PASS')
 ]) {
 for (host in hosts) {
 echo "Health checking ${host}..."

 sh """
 sshpass -p "\$DEPLOY_PASS" ssh -o StrictHostKeyChecking=no "\$DEPLOY_USER"@${host} "
 # 컨테이너 상태 확인
 sudo docker ps | grep pj-1 || exit 1
 "
 """

 echo "${host} health check passed."
 }
 }
 }
 }
 }
 }

5. 파이프라인 결과 체크

1
2
3
4
5
6
7
8
9


 post {
 success {
 echo "Deployment succeeded - ${IMAGE_NAME}:${params.IMAGE_TAG} deployed to ${env.DEPLOY_HOSTS}"
 }
 failure {
 echo "Deployment failed - check console output"
 }
 }
}

컨테이너 환경에서 Jenkins의 Java CICD 파이프라인 구축하기

Thu, 13 Nov 2025 09:00:00 +0900

Java 1.8 애플리케이션에 대한 CI/CD 파이프라인 설정 방법

환경

Git 리포지토리 및 컨테이너 레지스트리: GitLab
CI/CD: Jenkins
Java 버전: 1.8
빌드 툴: Maven
파이프라인을 컨테이너에서 동작시키기 위한 Jenkins Agent 도커 설정

파이프라인 설정

Git 리포지토리 연동
- Definition: Pipeline script from SCM
  - 파이프라인 구성에 필요한 스크립트를 SCM에서 가져오도록 설정
- SCM: Git
- Repository URL: Git 리포지토리 URL
- Credentials: Git 리포지토리에 접근 가능하도록 저장한 Credential
- Branch Specifier: */main

CI 파이프라인

컨테이너 이미지를 빌드하기 위한 Dockerfile도 Git 리포지토리에 있어야 함
Java는 빌드 과정이 필요한 컴파일 언어이기 때문에 소스 빌드 → 이미지 빌드 → 이미지 푸시 과정이 필요

환경

agent any로 jenkins agent 컨테이너를 파이프라인으로 사용

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


pipeline {
 agent any

 environment {
 WAR_FILE = '<WAR파일명>'
 BUILD_PROFILE = '<개발/운영>'
 MAVEN_OPTS = '-Xmx1024m -XX:MaxPermSize=256m'

 // Docker & GitLab Registry settings
 DOCKER_IMAGE = '<이미지명>'
 GITLAB_REGISTRY = '<컨테이너 레지스트리 URL>'
 GITLAB_PROJECT = '<Git 리포지토리명>'
 GITLAB_CREDENTIAL_ID = '<저장한 Git PAT 토큰 ID>'
 }

소스코드 체크아웃

Git 리포지토리의 최신 커밋을 체크아웃
파이프라인 로그에 커밋 정보 출력

1
2
3
4
5
6
7


 stages {
 stage('Checkout') {
 steps {
 checkout scm
 sh 'git log -1 --oneline'
 }
 }

Maven 빌드

Maven 컨테이너를 사용해서 소스 빌드
로컬 ~/.m2 디렉토리를 컨테이너하고 공유해서 의존성 캐시 재사용

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


 stage('Build') {
 agent {
 docker {
 image 'maven:3.9.11-eclipse-temurin-8'
 args '-v $HOME/.m2:/root/.m2'
 reuseNode true
 }
 }
 steps {
 script {
 def settingsParam = fileExists('settings.xml') ? '-s settings.xml' : ''

 sh """
 mvn clean package -P ${BUILD_PROFILE} -DskipTests=true ${settingsParam} \
 -Dmaven.compiler.source=1.8 \
 -Dmaven.compiler.target=1.8
 """

 sh """
 test -f target/${WAR_FILE} || (echo "WAR file not found" && exit 1)
 ls -lh target/${WAR_FILE}
 """
 }
 }
 }

Artifact 보관

빌드 메타데이터(commit, branch, build_time)를 build.properties로 저장
산출물을 Artifacts로 아카이빙
- Jenkins 콘솔에서 바로 WAR 파일 다운로드 가능

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


 stage('Archive') {
 steps {
 script {
 def gitCommit = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()
 def gitBranch = sh(returnStdout: true, script: 'git rev-parse --abbrev-ref HEAD').trim()
 def buildTime = sh(returnStdout: true, script: 'date "+%Y-%m-%d %H:%M:%S"').trim()

 writeFile file: 'build.properties', text: """BUILD_NUMBER=${env.BUILD_NUMBER}
BUILD_PROFILE=${BUILD_PROFILE}
GIT_COMMIT=${gitCommit}
GIT_BRANCH=${gitBranch}
BUILD_TIME=${buildTime}
"""
 }

 archiveArtifacts artifacts: "target/${WAR_FILE}, build.properties", fingerprint: true

 // WAR 파일을 workspace root로 복사 (Docker 빌드용)
 sh "cp target/${WAR_FILE} ."
 }
 }

컨테이너 이미지 빌드 및 레지스트리 푸시

Git 리포지토리에 있는 Dockerfile을 기반으로 이미지 빌드
Git 커밋 해시와 Jenkins 빌드 번호를 조합해서 태그 생성
GitLab PAT 토큰으로 로그인 후 푸시

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


 stage('Docker Build & Push') {
 steps {
 script {
 def gitCommit = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()
 def imageTag = "${env.BUILD_NUMBER}-${gitCommit}"
 def fullImageName = "${GITLAB_REGISTRY}/${GITLAB_PROJECT}/${DOCKER_IMAGE}"

 // Docker 이미지 빌드
 sh """
 docker build -t ${fullImageName}:${imageTag} .
 docker tag ${fullImageName}:${imageTag} ${fullImageName}:latest
 """

 // GitLab Container Registry 로그인 및 푸시
 withCredentials([usernamePassword(credentialsId: "${GITLAB_CREDENTIAL_ID}",
 usernameVariable: 'GITLAB_USER',
 passwordVariable: 'GITLAB_TOKEN')]) {
 sh """
 echo "\$GITLAB_TOKEN" | docker login ${GITLAB_REGISTRY} -u "\$GITLAB_USER" --password-stdin
 docker push ${fullImageName}:${imageTag}
 docker push ${fullImageName}:latest
 docker logout ${GITLAB_REGISTRY}
 """
 }

 echo "Docker image pushed: ${fullImageName}:${imageTag}"
 echo "Docker image pushed: ${fullImageName}:latest"
 }
 }
 }
 }
}

CD 파이프라인

Jenkins 서버에서 배포할 서버에 SSH로 접근 후 docker compose 파일을 기동하여 컨테이너 레지스트리의 이미지를 가져오는 방식으로 배포
배포할 서버가 여러 개일 경우를 고려해서 구성

환경

agent any로 jenkins agent 컨테이너를 파이프라인으로 사용

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


pipeline {
 agent any

 parameters {
 string(name: 'IMAGE_TAG', defaultValue: 'latest', description: 'Docker image tag to deploy')
 choice(name: 'DEPLOY_TARGET', choices: ['WAS1', 'ALL'], description: 'WAS1: <IP/HOSTNAME> | ALL: 전체 WAS 배포')
 }

 environment {
 WAS1_HOST = '<WAS1 서버 IP>'
 // WAS2_HOST = '<WAS2 서버 IP>' // TODO: WAS2 추가 시 활성화
 DEPLOY_PATH = '<배포 경로>'
 GITLAB_REGISTRY = '<컨테이너 레지스트리 URL>'
 GITLAB_PROJECT = '<Git 리포지토리명>'
 IMAGE_NAME = '<컨테이너 이미지 명>'
 DEPLOY_CREDENTIAL_ID = '<배포 서버 SSH 계정명>'
 GITLAB_CREDENTIAL_ID = '<저장한 Git PAT 토큰 ID>'
 }

준비

배포할 이미지 태그 / 배포 대상 서버를 선택할 수 있게 설정
deployHosts: 배포 대상 호스트 목록

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


 stages {
 stage('Prepare') {
 steps {
 script {
 echo "Deploying image: ${GITLAB_REGISTRY}/${GITLAB_PROJECT}/${IMAGE_NAME}:${params.IMAGE_TAG}"
 echo "Deploy target: ${params.DEPLOY_TARGET}"

 def deployHosts = []
 if (params.DEPLOY_TARGET == 'WAS1') {
 deployHosts = [WAS1_HOST]
 } else if (params.DEPLOY_TARGET == 'ALL') {
 deployHosts = [WAS1_HOST]
 // TODO: WAS2 추가 시 -> deployHosts = [WAS1_HOST, WAS2_HOST]
 }

 env.DEPLOY_HOSTS = deployHosts.join(',')
 echo "Target servers: ${env.DEPLOY_HOSTS}"
 }
 }
 }

배포

컨테이너 레지스트리에서 이미지 풀링
배포 경로에서 docker compose 명령어를 통한 애플리케이션 재기동

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


 stage('Deploy') {
 steps {
 script {
 def hosts = env.DEPLOY_HOSTS.split(',')

 withCredentials([
 usernamePassword(credentialsId: "${DEPLOY_CREDENTIAL_ID}",
 usernameVariable: 'DEPLOY_USER',
 passwordVariable: 'DEPLOY_PASS'),
 usernamePassword(credentialsId: "${GITLAB_CREDENTIAL_ID}",
 usernameVariable: 'GITLAB_USER',
 passwordVariable: 'GITLAB_TOKEN')
 ]) {
 for (host in hosts) {
 echo "Deploying to ${host}..."

 sh """
 sshpass -p "\$DEPLOY_PASS" ssh -o StrictHostKeyChecking=no \$DEPLOY_USER@${host} "
 cd ${DEPLOY_PATH}

 # GitLab Registry 로그인
 echo 'Logging in to GitLab Registry...'
 echo "\$GITLAB_TOKEN" | sudo docker login ${GITLAB_REGISTRY} -u "\$GITLAB_USER" --password-stdin

 # 이미지 Pull
 echo 'Pulling image: ${GITLAB_REGISTRY}/${GITLAB_PROJECT}/${IMAGE_NAME}:${params.IMAGE_TAG}'
 sudo docker pull ${GITLAB_REGISTRY}/${GITLAB_PROJECT}/${IMAGE_NAME}:${params.IMAGE_TAG}

 # 컨테이너 재배포
 echo 'Redeploying containers...'
 export IMAGE_TAG=${params.IMAGE_TAG}
 sudo docker compose down
 sudo docker compose up -d

 # 배포 확인
 echo 'Checking deployment status...'
 sudo docker compose ps

 # 로그아웃
 sudo docker logout ${GITLAB_REGISTRY}
 "
 """

 echo "Deployment to ${host} completed."
 }
 }
 }
 }
 }

헬스 체크

배포 완료 후 컨테이너 상태 점검

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


 stage('Health Check') {
 steps {
 script {
 echo "Waiting for application to start..."
 sleep 10

 def hosts = env.DEPLOY_HOSTS.split(',')

 withCredentials([usernamePassword(credentialsId: "${DEPLOY_CREDENTIAL_ID}",
 usernameVariable: 'DEPLOY_USER',
 passwordVariable: 'DEPLOY_PASS')]) {
 for (host in hosts) {
 echo "Health checking ${host}..."

 sh """
 sshpass -p "\$DEPLOY_PASS" ssh -o StrictHostKeyChecking=no \$DEPLOY_USER@${host} "
 # 컨테이너 상태 확인
 sudo docker ps | grep main

 # 헬스체크 (옵션)
 # curl -f http://localhost:8080/health || exit 1
 "
 """

 echo "${host} health check passed."
 }
 }
 }
 }
 }
 }
}

Jenkins Agent를 Docker로 동작시키기 위한 방법

Mon, 27 Oct 2025 09:00:00 +0900

Jenkins Agent가 도커로 사용되도록 설정 Jenkins Server-Agent 분리

Built-In-Node excutor 설정
- Jenkins Agent를 도커에서 동적으로 실행할거라 built-in-node의 Number of executors값을 0으로 설정
Agent Node 추가
- Manage Jenkins - Nodes - System Configuration - New Node
- Node 설정
  - Number of excutors: Jenkins Agent가 최대로 실행 가능한 파이프라인 수
  - Remote root directory: Jenkins Agent 컨테이너 내부의 루트 디렉토리
Agent 설치 스크립트 확인
- 이후에 컨테이너 기동에 필요한 secret 값이 포함되어 있으니 확인 필수

Dockerfile

파이프라인용 에이전트이므로 최소로 컨테이너 기동

1
2
3
4
5
6


FROM jenkins/inbound-agent:latest-jdk21
USER root
RUN apt-get update \
 && apt-get install -y docker.io ca-certificates openssh-client \
 && rm -rf /var/lib/apt/lists/*
USER jenkins

docker-compose.yaml

변수들은 .env 파일을 통해 별도로 설정
- JENKINS_URL: 도커 네트워크 인터페이스 docker0의 ip인 172.17.0.1를 기입
- JENKINS_SECRET: 위 콘솔에 나온 secret 값을 기입
- JENKINS_AGENT_NAME: 위에서 설정한 이름
- JENKINS_AGENT_WORKDIR: 위에서 설정한 Jenkins Agent가 컨테이너 내부에서 사용할 경로
- AGENT_WORKDIR: Jenkins Agent 컨테이너가 호스트에서 사용하는 실제 경로

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


version: "3.8"

services:
 agent:
 build:
 context: .
 dockerfile: Dockerfile
 container_name: jenkins-agent-docker
 restart: unless-stopped
 init: true
 environment:
 JENKINS_URL: "${JENKINS_URL}"
 JENKINS_SECRET: "${JENKINS_SECRET}"
 JENKINS_AGENT_NAME: "${JENKINS_AGENT_NAME}"
 JENKINS_AGENT_WORKDIR: "${JENKINS_AGENT_WORKDIR:-/home/jenkins/agent}"
 DOCKER_BUILDKIT: "1"
 JENKINS_WEB_SOCKET: "true"
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock
 - ${AGENT_WORKDIR:-/var/lib/jenkins_agent}:${JENKINS_AGENT_WORKDIR:-/home/jenkins/agent}
 group_add:
 - "${DOCKER_GID}"

컨테이너 권한 설정
- 호스트의 도커 소켓을 사용하는 DooD 방식이기 때문에 컨테이너에서도 호스트의 도커 GID 동기화 필요
  - /var/lib/jenkins_agent: 호스트에 컨테이너 데이터가 저장될 경로.
    - 컨테이너 내부에서도 기록해야하니 기본 사용자인 1000으로 설정
1 2

echo "DOCKER_GID=$(stat -c %g /var/run/docker.sock)" >> .env mkdir -p /var/lib/jenkins_agent && chown 1000:1000 /var/lib/jenkins_agent
Jenkins Agent 빌드
1

docker compose up -d --build
Node 연결 확인
파이프라인 테스트
- hello world 테스트 성공!

참고

Jenkins Agent 노드 추가: https://github.com/jenkinsci/docker-agent/blob/master/README_inbound-agent.md

Linux 환경에서 Jenkins 설치

Thu, 23 Oct 2025 09:00:00 +0900

로컬 리눅스 환경에서 Jenkins 설치하는 방법

환경

OS: Rocky 8.10
java: OpenJDK 21

설치

패키지 설치

1
2
3
4


wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

yum install fontconfig java-21-openjdk

(선택) OpenJDK 21이 아닌 다른 버전으로 선택되어 있을 시 변경 필요

1
2
3
4


java --version
# java 21 선택
alternatives --config java
java --version

jenkins 설치

1
2
3


yum install jenkins
systemctl daemon-reload
systemctl enable --now jenkins

http://:8080으로 콘솔 접근
Install wizard 진행
- jenkins는 최초 접근 시 unlock 되어 있음
  - 비밀번호 확인 필요
  1
  
  cat /var/lib/jenkins/secrets/initialAdminPassword
- 이후 자동 설치 진행

참고

Jenkins Install 공식 문서: https://www.jenkins.io/doc/book/installing/linux/

K8S에 구축된 Jenkins-GitLab CI Jenkinsfile - 애플리케이션 빌드 필요 없는 경우

Fri, 17 Oct 2025 09:00:00 +0900

Kubernetes 환경에서 Jenkins 파이프라인으로 CI를 수행하도록 구성한 Jenkinsfile 정리

Jenkins와 GitLab이 같은 K8S에 있는 환경인 가정하에 유효

Python, PHP처럼 애플리케이션 빌드 과정이 필요 없는 인터프리터 언어 기반인 경우에 유효

1. Kubernetes Pod 템플릿

Jenkins 에이전트를 파드 단위로 생성하는 파드 템플릿 정의
docker, dind 컨테이너로 구성
- docker-daemon 컨테이너는 Docker in Docker(DIND)를 사용해서 도커 데몬 실행
workspace-volume와 docker-socket 볼륨 공유

hostNetwork: true 설정으로 파드의 컨테이너가 호스트 노드(현재 워커 노드)의 네트워크 네임스페이스를 사용할 수 있도록 설정

hostAliases 설정으로 사설 IP로 GitLab 서버에 접근할 수 있도록 설정

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


 agent {
 kubernetes {
 yaml """
 apiVersion: v1
 kind: Pod
 spec:
 serviceAccountName: jenkins
 hostNetwork: true
 hostAliases:
 - ip: "<마스터 서버 사설 IP>"
 hostnames:
 - "registry.<도메인>"
 - "gitlab.<도메인>"
 containers:
 - name: docker
 image: docker
 command:
 - sleep
 args:
 - 99d
 tty: true
 volumeMounts:
 - name: workspace-volume
 mountPath: /home/jenkins/agent
 - name: docker-socket
 mountPath: /var/run
 - name: docker-daemon
 image: docker:dind
 securityContext:
 privileged: true
 env:
 - name: DOCKER_TLS_CERTDIR
 value: ""
 args:
 - --insecure-registry=registry.<도메인>:8080
 volumeMounts:
 - name: docker-socket
 mountPath: /var/run
 volumes:
 - name: workspace-volume
 emptyDir: {}
 - name: docker-socket
 emptyDir: {}
 """
 }
 }

2. Environment

Jenkinsfile에서 사용될 전역 환경 변수 정의

GITLAB_REGISTRY: GitLab Registry 주소
GITLAB_TOKEN: Jenkins Credentials에 저장된 GitLab 토큰

1
2
3
4
5
6
7
8


 environment {
 APP_NAME = "<앱 이름>"
 RELEASE = "1.0.0"
 GITLAB_REGISTRY = "registry.<도메인>:8080"
 GITLAB_TOKEN = credentials('<credentials 이름>')
 IMAGE_NAME = "${GITLAB_REGISTRY}/root/${APP_NAME}"
 IMAGE_TAG = "${RELEASE}-${BUILD_NUMBER}"
 }

3. Stages

Stage 1

SCM에서 소스코드 체크아웃
SCM의 url은 K8S Service의 FQDN으로 사용

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


 stage("Checkout from SCM") {
 steps {
 script {
 sh 'pwd'
 sh 'ls -al'
 git credentialsId: '<credentials 이름>',
 url: 'http://gitlab-webservice-default.gitlab.svc.cluster.local:8181/root/<리포지토리명>.git',
 branch: 'main'
 sh 'ls -al'
 }
 }
 }

Stage 2

Docker 이미지 빌드
- DinD 컨테이너에서 이미지 빌드 및 태그 추가

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


 stage('Build Docker Image') {
 steps {
 container('docker') {
 script {
 sh 'pwd'
 sh 'ls -al'
 sh 'docker build --no-cache -t ${IMAGE_NAME}:${IMAGE_TAG} .'
 sh 'docker tag ${IMAGE_NAME}:${IMAGE_TAG} ${IMAGE_NAME}:latest'
 }
 }
 }
 }

Stage 3

GitLab Registry 이미지 푸시
- GitLab Container Registry에 로그인 후 이미지 푸시
- GITLAB_TOKEN 환경변수에서 주입받은 credential로 GITLAB_TOKEN_PSW, GITLAB_TOKEN_USR 변수 사용 가능

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


stage('Push to GitLab Registry') {
 steps {
 container('docker') {
 script {
 sh 'echo $GITLAB_TOKEN_PSW | docker login ${GITLAB_REGISTRY} -u $GITLAB_TOKEN_USR --password-stdin'
 sh 'docker push ${IMAGE_NAME}:${IMAGE_TAG}' // Docker 이미지 푸시
 sh 'docker push ${IMAGE_NAME}:latest' // Docker 이미지 푸시(latest 태그)
 }
 }
 }
 }

4. 정리

파이프라인 종료 전 도커 리소스 정리 및 로그아웃

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


 post {
 always {
 // 작업 완료 후 정리
 container('docker') {
 script {
 sh 'docker logout ${GITLAB_REGISTRY} || true'
 sh 'docker system prune -f || true'
 }
 }
 }
 success {
 echo "Pipeline succeeded! Image ${IMAGE_NAME}:${IMAGE_TAG} pushed to GitLab Registry"
 }
 failure {
 echo "Pipeline failed!"
 }
 }

전체 Jenkinsfile

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115


pipeline {
 agent {
 kubernetes {
 yaml """
 apiVersion: v1
 kind: Pod
 spec:
 serviceAccountName: jenkins
 hostNetwork: true
 hostAliases:
 - ip: "<마스터 서버 사설 IP>"
 hostnames:
 - "registry.<도메인>"
 - "gitlab.<도메인>"
 containers:
 - name: docker
 image: docker
 command:
 - sleep
 args:
 - 99d
 tty: true
 volumeMounts:
 - name: workspace-volume
 mountPath: /home/jenkins/agent
 - name: docker-socket
 mountPath: /var/run
 - name: docker-daemon
 image: docker:dind
 securityContext:
 privileged: true
 env:
 - name: DOCKER_TLS_CERTDIR
 value: ""
 args:
 - --insecure-registry=registry.<도메인>:8080
 volumeMounts:
 - name: docker-socket
 mountPath: /var/run
 volumes:
 - name: workspace-volume
 emptyDir: {}
 - name: docker-socket
 emptyDir: {}
 """
 }
 }

 environment {
 APP_NAME = "<앱 이름>"
 RELEASE = "1.0.0" // 릴리즈 버전
 GITLAB_REGISTRY = "registry.<도메인>:8080" // GitLab Registry 주소
 GITLAB_TOKEN = credentials('<credentials 이름>') // Jenkins Credentials에 저장된 GitLab 토큰
 IMAGE_NAME = "${GITLAB_REGISTRY}/root/${APP_NAME}" // 이미지 이름
 IMAGE_TAG = "${RELEASE}-${BUILD_NUMBER}" // 이미지 태그
 }

 stages {
 stage("Checkout from SCM") { // 소스 코드 관리(SCM)에서 체크아웃 단계
 steps {
 script {
 sh 'pwd'
 sh 'ls -al'
 git credentialsId: '<credentials 이름>', // GitLab 자격증명 사용
 url: 'http://gitlab-webservice-default.gitlab.svc.cluster.local:8181/root/<리포지토리명>.git', // GitLab 리포지토리 URL
 branch: 'main' // 브랜치 이름
 sh 'ls -al'
 }
 }
 }

 stage('Build Docker Image') { // Docker 이미지 빌드 단계
 steps {
 container('docker') {
 script {
 sh 'pwd'
 sh 'ls -al'
 sh 'docker build --no-cache -t ${IMAGE_NAME}:${IMAGE_TAG} .' // Docker 이미지 빌드
 sh 'docker tag ${IMAGE_NAME}:${IMAGE_TAG} ${IMAGE_NAME}:latest' // latest 태그 추가
 }
 }
 }
 }

 stage('Push to GitLab Registry') { // GitLab Registry에 이미지 푸시 단계
 steps {
 container('docker') {
 script {
 sh 'echo $GITLAB_TOKEN_PSW | docker login ${GITLAB_REGISTRY} -u $GITLAB_TOKEN_USR --password-stdin' // GitLab Registry 로그인
 sh 'docker push ${IMAGE_NAME}:${IMAGE_TAG}' // Docker 이미지 푸시
 sh 'docker push ${IMAGE_NAME}:latest' // Docker 이미지 푸시(latest 태그)
 }
 }
 }
 }
 }

 post {
 always {
 // 작업 완료 후 정리
 container('docker') {
 script {
 sh 'docker logout ${GITLAB_REGISTRY} || true'
 sh 'docker system prune -f || true'
 }
 }
 }
 success {
 echo "Pipeline succeeded! Image ${IMAGE_NAME}:${IMAGE_TAG} pushed to GitLab Registry"
 }
 failure {
 echo "Pipeline failed!"
 }
 }
}

K8S에 구축된 Jenkins-GitLab 파이프라인 설정

Thu, 16 Oct 2025 09:00:00 +0900

파이프라인 설정

Definition: Pipeline script from SCM
- SCM: Git
  - Jenkinsfile을 Git으로 읽도록 설정
git repository url: http://gitlab-webservice-default.gitlab.svc.cluster.local:8181/root/test.git
- Jenkins 서버와 GitLab 서버가 모두 같은 k8s 클러스터에 있으므로, 외부 서버에서 url 설정하던 것처럼 하긴 어려움
- GitLab UI Service의 FQDN인 gitlab-webservice-default.gitlab.svc.cluster.local 을 사용
Credentials: GitLab PAT
- GitLab의 사용자/리포지토리에서 발급한 PAT를 Jenkins Credentials에 등록해서 사용
Branches to build: */main
- 빌드할 브랜치 선택

K8S에 구축한 Jenkins CI 파이프라인의 Dind 네트워크 에러 TroubleShooting

Sat, 27 Sep 2025 09:00:00 +0900

K8S 환경의 Jenkins에서 docker build가 Jenkins 파이프라인 파드의 dind 컨테이너에서 실행되기 때문에 발생한 이슈

환경

Jenkins 서버를 K8S에서 구축하고, 파이프라인을 K8S 파드에서 동작하도록 설정한 환경
- Jenkinsfile에서 K8S 파드 템플릿으로 파이프라인 실행하게 명시

문제 상황

Jenkinsfile의 docker build 단계에서 파이프라인 빌드 실패
- Dockerfile의 composer install 레이어에서 Could not fetch https://api.github.com/repos/ 에러 발생
- 외부에서 데이터를 받아오는 명령어에서 전부 timeout 에러 발생

에러 분석

Jenkins 파이프라인이 K8S 파드의 docker 컨테이너에서 실행되고, docker build 작업은 dind 컨테이너에서 실행됨
- dind 컨테이너 입장에서 네트워크가 격리되어 있어 GitHub API 서버로의 아웃바운드 연결 불가
따라서 composer install 와 같은 명령어 실행 시 연결 실패 에러 발생

해결 방법

Jenkinsfile의 k8s 파드 템플릿에 hostNetwork: true를 설정해서 파드의 컨테이너가 호스트 노드(현재 워커 노드)의 네트워크 네임스페이스를 사용할 수 있도록 설정
- 파드 템플릿이 아닌 docker build --network=host로 명령어 마다 옵션을 명시해서 해결도 가능하지만, 파드 레벨에서 해결하는게 관리에 용이

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


kubernetes {
 yaml """
 apiVersion: v1
 kind: Pod
 spec:
 serviceAccountName: jenkins
 hostNetwork: true
 hostAliases:
 - ip: "172.27.1.9"
 hostnames:
 - "registry.<도메인>"
 - "gitlab.<도메인>"
 containers:
 - name: docker
 image: docker
 command:
 - sleep
 args:
 - 99d
 tty: true
 volumeMounts:
 - name: workspace-volume
 mountPath: /home/jenkins/agent
 - name: docker-socket
 mountPath: /var/run
 - name: docker-daemon
 image: docker:dind
 securityContext:
 privileged: true
 env:
 - name: DOCKER_TLS_CERTDIR
 value: ""
 args:
 - --insecure-registry=registry.<도메인>:8080
 volumeMounts:
 - name: docker-socket
 mountPath: /var/run
 volumes:
 - name: workspace-volume
 emptyDir: {}
 - name: docker-socket
 emptyDir: {}
 """
 }

Jenkins 파이프라인을 K8S Pod로 사용하기 위한 설정

Wed, 17 Sep 2025 09:00:00 +0900

Jenkins 파이프라인이 K8S pod로 사용되도록 설정

Helm으로 설치 시에는 하기 설정들이 자동으로 세팅되어 있으니 설정 불필요

Jenkins에 Kubernetes 플러그인 설치 확인
- Jenkins가 K8S API와 통신해서 pod(파이프라인 에이전트)를 생성/삭제 가능하도록 설정
Built-In-Node excutor 설정
- 파이프라인 에이전트를 k8s pod에서 동적으로 실행할거라 built-in-node(jenkins 서버 pod)의 Number of executors을 0으로 설정
K8S Configure
- Manage Jenkins > Clouds > New Cloud / Configure
- K8S URL로 Test Connection 확인
- Jenkins URL/Tunnel
  - Jenkins URL: http://jenkins.jenkins.svc.cluster.local:8080
  - Jenkins tunnel: jenkins-agent.jenkins.svc.cluster.local:50000
    - jenkins tunnel은 jnlp(파이프라인 에이전트 관리 pod)로 연결되는 FQDN 입력
    - jnlp 포트가 50000
  - url, tunnel에 도메인을 넣으면 IP가 바뀌더라도 연결 가능
    - K8S FQDN: 클러스터 DNS 규칙에 의해 만들어짐
      - FQDN 룰: <Service명>.<Namespace명>.svc.
      - cluster domain 기본값은 cluster.local
    - FQDN 예시
      - jenkins FQDN: jenkins.jenkins.svc.cluster.local
      - jenkins-agent FQDN: jenkins-agent.jenkins.svc.cluster.local
      1 2 3 4
      
      # kubectl get svc -n jenkins NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE jenkins ClusterIP 10.233.54.119 <none> 8080/TCP 11d jenkins-agent ClusterIP 10.233.57.212 <none> 50000/TCP 11d
Pod Template

파이프라인 에이전트가 K8S에서 Pod로 관리될 때의 Pod 설정을 정의

자체 관리형 Kubernetes에서의 Jenkins 구축

Fri, 29 Aug 2025 09:00:00 +0900

매니지드 K8S가 아닌 자체 관리형 K8S에서의 Jenkins 구축 방법

UI 접근을 위한 외부 통신으로 MetalLB+HAproxy+Nginx Controller가 구성 되었다는 전제 하에 구축

CSP 환경이라면 Ingress 설정에서 AWS ALB Controller와 같은 로드밸런서를 사용해 훨씬 간편하게 구축 가능

Jenkins 공식문서: ****https://www.jenkins.io/doc/book/installing/kubernetes/

Jenkins 설치

Helm 리포지토리 추가

1
2


helm repo add jenkinsci https://charts.jenkins.io
helm repo update

jenkins-ci 네임스페이스 생성
1

kubectl create ns jenkins

jenkins-pv 생성(기존 StorageClass 없을 시에만 진행)

기존에 사용하던 Ceph, Longhorn, EBS Driver, Harbor 같은 StorageClass가 없을 경우에 로컬 경로를 사용한 PV 할당 방법
- StorageClass가 있다면 PVC 생성 시 자동으로 PV가 할당되기 때문에 이 과정은 불필요

1
2


vim jenkins-01-volume.yaml
kubectl apply -f jenkins-01-volume.yaml

https://raw.githubusercontent.com/jenkins-infra/jenkins.io/master/content/doc/tutorials/kubernetes/installing-jenkins-on-kubernetes/jenkins-01-volume.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


apiVersion: v1
kind: PersistentVolume
metadata:
 name: jenkins-pv
spec:
 storageClassName: jenkins-pv
 accessModes:
 - ReadWriteOnce
 capacity:
 storage: 20Gi
 persistentVolumeReclaimPolicy: Retain
 hostPath:
 path: /data/jenkins-volume/

---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
 name: jenkins-pv
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer

ServiceAccount 생성

1
2


vim jenkins-02-sa.yaml
kubectl apply -f jenkins-02-sa.yaml

https://raw.githubusercontent.com/jenkins-infra/jenkins.io/master/content/doc/tutorials/kubernetes/installing-jenkins-on-kubernetes/jenkins-02-sa.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76


---
apiVersion: v1
kind: ServiceAccount
metadata:
 name: jenkins
 namespace: jenkins
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
 annotations:
 rbac.authorization.kubernetes.io/autoupdate: "true"
 labels:
 kubernetes.io/bootstrapping: rbac-defaults
 name: jenkins
rules:
- apiGroups:
 - '*'
 resources:
 - statefulsets
 - services
 - replicationcontrollers
 - replicasets
 - podtemplates
 - podsecuritypolicies
 - pods
 - pods/log
 - pods/exec
 - podpreset
 - poddisruptionbudget
 - persistentvolumes
 - persistentvolumeclaims
 - jobs
 - endpoints
 - deployments
 - deployments/scale
 - daemonsets
 - cronjobs
 - configmaps
 - namespaces
 - events
 - secrets
 verbs:
 - create
 - get
 - watch
 - delete
 - list
 - patch
 - update
- apiGroups:
 - ""
 resources:
 - nodes
 verbs:
 - get
 - list
 - watch
 - update
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
 annotations:
 rbac.authorization.kubernetes.io/autoupdate: "true"
 labels:
 kubernetes.io/bootstrapping: rbac-defaults
 name: jenkins
roleRef:
 apiGroup: rbac.authorization.k8s.io
 kind: ClusterRole
 name: jenkins
subjects:
- apiGroup: rbac.authorization.k8s.io
 kind: Group
 name: system:serviceaccounts:jenkins

jenkins 설치

https://github.com/jenkinsci/helm-charts/tree/main/charts/jenkins

helm으로 설치
values.yaml 수정

1
2
3
4


wget https://raw.githubusercontent.com/jenkinsci/helm-charts/main/charts/jenkins/values.yaml
vim values.yaml

helm install jenkins -n jenkins -f values.yaml jenkinsci/jenkins

helm을 통해 pvc 자동 생성

pv는 longhorn이 자동으로 프로비저닝
SA는 2번에서 생성한 리소스 사용

1
2
3
4
5
6
7


persistence:
 storageClass: longhorn
 size: "20Gi"

serviceAccount:
 create: false
 name: jenkins

Jenkins UI 접근

ingress 생성

8080포트를 사용하는 jenkins service로 연결

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


cat <<EOF > jenkins-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
 name: jenkins-ingress
 namespace: jenkins
 annotations:
 nginx.ingress.kubernetes.io/backend-protocol: "HTTP"
 nginx.ingress.kubernetes.io/proxy-body-size: "50m"
spec:
 ingressClassName: nginx
 rules:
 - host: "jenkins.<도메인>"
 http:
 paths:
 - path: /
 pathType: Prefix
 backend:
 service:
 name: jenkins
 port:
 number: 8080
EOF

kubectl -n jenkins apply -f jenkins-ingress.yaml

HAproxy 설정

ingress를 조회하여 MetalLB로부터 부여받은 IP 확인

현재는 172.27.1.100

1
2
3


# kubectl get ingress -n jenkins
NAME CLASS HOSTS ADDRESS PORTS AGE
jenkins-ingress nginx jenkins.<도메인> 172.27.1.100 80 26h

확인한 IP를 HAproxy 설정에 추가

HAproxy 서버 공인 IP로 접근 시 jenkins의 Ingress로 통신되도록 설정
http-response replace-value Location ^http://jenkins\.<도메인>/(.*)$ http://jenkins.<도메인>:<포트>/\\1
두 조건을 만족할 경우 설정 필요
- 외부 브라우저에서 Jenkins 접근 시 포트를 붙여서 접근해야 될 경우
- 애플리케이션 내부적으로 url로 응답이 나오도록 설정되어 있을 경우
  - EX) Jenkins 파이프라인 빌드 시 파라미터를 기입해야 할 경우 Jenkins 설정된 url 응답
설정하지 않으면 접근 시 자동으로 포트가 제거된 상태로 리다이렉션되어 404 에러

1
2
3


vim /etc/haproxy/haproxy.cfg
haproxy -c -f /etc/haproxy/haproxy.cfg
systemctl reload haproxy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


frontend unified_frontend_8080
 bind *:8080
 mode http
 option forwardfor

 http-request set-header X-Forwarded-Host %[req.hdr(host)]
 http-request set-header X-Forwarded-Proto http
 http-request set-header X-Forwarded-Port %[dst_port]

 # Host 기반 라우팅
 use_backend metallb_backend_jenkins if { hdr(host) -m sub jenkins }

backend metallb_backend_jenkins
 http-response replace-value Location ^http://jenkins\.<도메인>/(.*)$ http://jenkins.<도메인>:<포트>/\\1
 server jenkins 172.27.1.100:80

접근 성공!

Jenkins 관리자 비밀번호 확인

1
2
3


jsonpath="{.data.jenkins-admin-password}"
secret=$(kubectl get secret -n jenkins jenkins -o jsonpath=$jsonpath)
echo $(echo $secret | base64 --decode)