네이버 클라우드 부트캠프/복습 정리

NaverCloudPLATFORM Server 생성 방법

유정♡ 2024. 7. 15. 11:20

https://console.ncloud.com/dashboard


[ NaverCloudPLATFORM Server 생성 ]

1) Service -> Server 

 

2) + 서버 생성 -> 부팅 디스크 크기 

 

3) vpc 생성 먼저 -> VPC 이름은 자유롭게 -> IP는 172.16.0.0/16(강사님따라한주소)

    subnet 생성 먼저 -> IP는 172.16.0.0/24(강사님따라한주소)

 

4) 서버 설정 -> SSD g2 Standard 

 

5) 인증키 설정 -> 새로운 인증키 생성 -> 인증키 이름 자유롭게 설정 -> 인증키 생성 및 저장 버튼 클릭 -> 다운로드 된 파일 위치 잘 저장

 

6) 네트워크 접근 설정 -> ACG(별도의 방화벽 구축없이, 서버 그룹에 대한 네트워크 접근 제어 및 관리를 돕는 상품)

 

7) 최종 확인

 

8) 서버 생성 중 -> 운영중이라고 뜨면 서버가 생성 된 상태 

 

 


[ iterm SSH 원격 접속 ]

1) 서버 관리 및 설정 변경 -> 관리자 비밀번호 확인 -> pem 파일 등록 후 비밀번호 확인 클릭 

 

2) iterm 명령어 -> 🩷 ssh 아이디@아이피 -> 이때 아이피는 공인 IP (Instance ID) 주소 입력

 


[ 도커 설치 ] 

🩷 도커를 우분투(가상머신)에 설치하는 작업 

 

1) 우분투 시스템 패키지 업데이트

sudo apt-get update

 

2) 우분투에 필요한 패키지 설치

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

 

3) Docker에 공식 GPG키를 추가

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

 

4) Docker에 공식 apt 저장소를 추가

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

 

5) 시스템 패키지 업데이트

sudo apt-get update

 

6) 우분투 시스템에 Docker 설치하는 명령어 -> docker-ce, docker-ce-cli, containerd.io 총 세개 패키지 설치

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

 

7) Docker가 설치 확인

    7-1) 도커 실행상태 확인 -> Active: active (running) since Mon 2024-07-15 11:14:19 KST; 10s ago 실행이 잘 된 상태 

sudo systemctl status docker

   

    7-2) 도커 실행

sudo docker run hello-world

 


 

[ 젠킨스를 도커에 설치 CI/CD ]

1) 🩷 Jenkins의 컨테이너를 실행하는 명령어 입력

    Jenkins는 DevOps에서 CI/CD(Continuous Integration/Continuous Deployment)를 구현하는 데 널리 사용되는 도구이다.

    이 명령어는 Jenkins를 Docker 컨테이너로 실행하며, 다양한 옵션을 통해 설정을 지정한다.

docker run \
  --name jenkins_1 \  --생성되는 컨테이너 이름 : jenkins_1
  -p 8081:8080 \  --8081 port를 컨테이너 8080 port에 매핑
  -e TZ=Asia/Seoul \
  -v /docker_projects/jenkins_1/var/jenkins_home:/var/jenkins_home \
  -v /var/run/docker.sock:/var/run/docker.sock \   --젠킨스가 도커 사용가능하게
  -v /docker_projects/jenkins_1/data:/data \
  -u root \
  -d \
  --restart unless-stopped \  --컨테이너가 중지되지 않는 한 항상 재시작하도록 설정합니다. 시스템 재부팅 후에도 자동으로 시작
  jenkins/jenkins:lts  --사용할 Docker 이미지를 지정합니다.

 

2) 실행중인 컨테이너에서(=exec jenkins_1) 초기 관리자 비밀번호 출력 -> c415435b17ca4a5aa6e900b5f1048504

docker exec jenkins_1 cat /var/jenkins_home/secrets/initialAdminPassword

 

 

3) 왼쪽 클릭 -> Install suggested plugins

 

4)

 

5) 모든 입력칸 임의로 적으면 됨 정해진 규칙 x

 

6) URL로 접속

 

7) Start using Jenkins 버튼 클릭 ! -> 사용자이름 + 비밀번호로 로그인 가능 

 

8) 도커에 설치한 젠킨스로 들어간다 -> 실행중인 jenkins_1 컨테이너에 접속해서 bash쉘 시작

     -> 컨테이너 내부에서 직접 명령어 실행 가능

docker exec -it jenkins_1 bash

 

9) mlocate 설치 (시스템 파일을 좀 더 빠르게 검색, 실행 시켜주는 프로그램)

apt update

apt install mlocate

 

10) 젠킨스에 접속한다

apt-get update -y   ------------------------------------------------패키지 업데이트
​

apt-get install -y ca-certificates curl gnupg lsb-release
​

mkdir -p /etc/apt/keyrings     --------------------------------키 저장소 생성
​

rm /etc/apt/keyrings/docker.gpg     -----------------------------기존 docker gpg 키 제거
​

curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg    --docker 공식 gpg 키 추가
​

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
$(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null    --docker 저장소 추가
​

apt-get update   ------------------------------------------------패키지 업데이트
​

apt-get install -y docker-ce docker-ce-cli docker-compose-plugin    -- docker관련 패키지 설치
​

exit  --- 셸 종료

 

11) 디렉토리 생성 -> 이미 있을 수도 있음

sudo mkdir /docker_projects

 

  11-1) docker_projects/aaaaa/project 안에 있는 파일 강제 삭제

sudo rm -rf /docker_projects/aaaaa/project

 

   11-2) makedirectory -> 디렉토리 프로젝트 생성 

sudo mkdir -p /docker_projects/aaaaa/project

 

   11-3) 생성한 디렉토리 파일로 이동 cd

cd/ docker_projects/aaaaa/project

 

12) 이때 만약 11번 작업이 안 된다면 아래 작업 해주고 하기

apt-get update

apt-get install sudo

 

13) 생성한 project를 깃허브에 올리는 작업 -> 프로젝트를 깃허브에 올릴 때 Dockerfile 파일 생성하고 도커 plugin설치

      -> 이때 두번째줄 simple1은 프로젝트명 적기 

FROM openjdk:17
ARG JAR_FILE=build/libs/simple1-0.0.1-SNAPSHOT.jar
COPY ${JAR_FILE} app.jar    #생성한 프로젝트를 app.jar(도커 루트 디렉토리)에 복사 
ENTRYPOINT ["java","-jar","/app.jar"]

    -> 인텔리제이에 Dockerfile 넣기

14) 인텔리제이에 simple1 프로젝트 파일 열고 깃허브에 repository 생성하고 파일 업로드

git init

git commit -m "fisrt commit"

git add . -> 커밋할 사항을 추가하지 않았지만 추적하지 않는 파일이 있습니다 (추적하려면 "git add"를 사용하십시오) 라고 뜰 경우 

git remote add origin https://github.com/yujung1339/jenkinsProject.git

git push -u origin main

 


15) iterm으로 돌아와서 git clone -> repository 주소 복사 

git clone https://github.com/yujung1339/jenkinsProject.git

 

     15-1) ls로 잘 들어갔는지 확인 -> cd 리파지토리이름

cd jenkinsProject

 

16) 소유권 변경하는 작업 -> changemode 소유권을 744로 변경하겠다

chmod 744 ./gradlew

 

17) java version 확인 -> not found 뜸 java 설치 안 되어 있음, java 권한을 따로 설정해줘야 함

java -version

 

18) java 권한 설정 -> 우분투환경에 자바 권한 준다 

sudo apt update

sudo apt install openjdk-17-jdk

 

19) gradle project clean build 

./gradlew clean build

 

20) git pull + 도커 이미지 빌드 

cd /docker_projects

cd aaaaa

cd project

cd jenkinsProject

ls

cd build

ls

cd libs

cd .. (상위 디렉토리로 이동) - jenjen이있는 위치까지


git pull


docker build -t aaaaa .    //도커 이미지 빌드 (도커파일을 찾아 도커 이미지 생성해 aaaaa라는 태그로 지정함)

[ Jenkins Pipeline ]

1) Jenkins 로그인 

 

2) 공인아이피:포트번호/view/all/newJob 주소로 들어가기 -> name 정해주고 Pipeline 클릭 후 OK

 

3) GitHub 들어간 것만 클릭, GitHub Project url은 깃허브 Repository 주소 복붙 -> 🩷 Pipeline script 작성

     ( git에서 코드 클론 -> gradle을 이용해서 프로젝트 빌드&테스트 -> 기존 docker 이미지 중지/제거 -> 새 docker 이미지 빌드

       -> 새 doker 이미지 사용해 docker 컨테이너 실행 -> 도커에서 하던 실행을 Jenkins에서 하겠단 의미 ? )

pipeline {
    agent any
    
    tools {
        jdk 'openjdk-17-jdk'
    }
    
    stages {
        stage('Prepare') {
            steps {
                git branch: 'main',
                    url: 'https://github.com/yujung1339/jenkinsProject.git'   --본인 깃 주소로 바꾸기 
            }
            
            post {
                success { 
                    sh 'echo "Successfully Cloned Repository"'
                }
                failure {
                    sh 'echo "Fail Cloned Repository"'
                }
            }    
        }
        
        stage('Build Gradle Test') {
            
            steps {
                sh (script:'''
                    echo "Build Gradle Test Start"
                ''')

                dir('.') {
                    sh """
                    chmod +x gradlew
                    """
                }
                
                dir('.') {
                    sh """
                    ./gradlew clean build
                    """
                }
            }
            
            post {
                success { 
                    sh 'echo "Successfully Build Gradle Test"'
                }
                 failure {
                    sh 'echo "Fail Build Gradle Test"'
                }
            }    
        }
        
        stage('Docker Rm') {
            steps {
                sh 'echo "Docker Run Start"'
                sh """
                docker stop timecapsule
                docker rm -f timecapsule
                docker rmi -f timecapsule
                """
            }
            
            post {
                success { 
                    sh 'echo "Docker Rm Success"'
                }
                failure {
                    sh 'echo "Docker Rm Fail"'
                }
            }
        }
        
        stage('Bulid Docker Image') {
            steps {
                sh 'echo " Image Bulid Start"'
                sh """
                docker build -t timecapsule .
                """
            }
            
            post {
                success {
                    sh 'echo "Bulid Docker Image Success"'
                }

                failure {
                    sh 'echo "Bulid Docker Image Fail"'
                }
            }
        }
        
        stage('Docker Run') {
            steps {
                sh 'echo "Docker Run Start"'
                sh """
                docker run \
                  --name=timecapsule \
                  -p 80:8080 \
                  -v /docker_projects/aaaaa/volumes/gen:/gen \
                  --restart unless-stopped \
                  -e TZ=Asia/Seoul \
                  -d \
                  timecapsule
                """
            }
            
            post {
                success {
                    sh 'echo "Docker Run Success"'
                }

                failure {
                    sh 'echo "Docker Run Fail"'
                }
            }
        }
    }
}

 


[ Jenkins JDK ]

1) 공인아이피주소:포트번호/manage/configureTools/

 

2) Add JDK -> JDK installations에서 -> Name : openkdj-17-jdk & JAVA_HOME : /opt/java/openjdk -> save

 


[ timecapsule 설치 -> Pipleline script에서 설정한 것 이것까지 해줘야 함 ]

1) iterm -> 🩷 docker build -t timecapsule .

2) docker image 잘 확인 됐는지 확인 -> 🩷 docker image ls -> timecapsule 잘 뜨는지 확인 가능 

 

3) docker run -> timecapsule -> docker에서 run을 해줘야지 실질적으로 Jenkins에서 사용 가능 

docker run \
  --name=timecapsule \
  -p 8080:8080 \
  -v /docker_projects/aaaaa/volumes/gen:/gen \
  --restart unless-stopped \
  -e TZ=Asia/Seoul \
  -d \
  timecapsule

 

4) 🩷 curl http://localhost:8080

 

5) 다시 Jenkins로 돌아와서 -> 지금 빌드 클릭


[ GitHub Webhook 과 Jenkins 연동 ] 

1) Setting -> Developers Setting -> Personal access tokens -> Tokens(classic) -> Generate new token(classic)

     -> 기간 No expiration + repo랑 admin:repo_hook 체크

 

2) jenikinsProject의 Repository로 돌아와서 -> Settings -> Webhooks -> Add webhook

 

3) Payload URL : 젠킨스 주소 (=공인아이피주소:포트번호/github_webhook/) & Content type : application/json

                             SSL verification : Disable, Which events : Just the push event, Active 체크

 

4) Jenkins 관리 -> 공인아이피주소:포트번호/manage/credentials/ -> (global) 클릭 -> Add Credentials 클릭 

 

5) Username : Github 이름(=yujung1339) & Password : Token & ID : github_access_token(임의로지으면됨)

     -> 깃허브에서 액세스 토큰 만들어서 웹훅 생성 완료 

6) Dashboard -> 새로운 Item -> Pipeline 생성 -> (위랑똑같) GitHub만 체크(=2개) + GitHub project에 Repository 주소 입력

    -> Pipeline script 12번째줄에 credentialsId: 'github_access_token' 추가 -> 지금 빌드 

         (이때 저 이름은 Dashboard -> Jenkins 관리 -> Credentials에 ID랑 똑같아야함) 

pipeline {
    agent any
    
    tools {
        jdk 'openjdk-17-jdk'
    }
    
    stages {
        stage('Prepare') {
            steps {
                git branch: 'main',
                    credentialsId: 'github_access_token',
                    url: 'https://github.com/yujung1339/jenkinsProject.git'
            }
            
            post {
                success { 
                    sh 'echo "Successfully Cloned Repository"'
                }
                failure {
                    sh 'echo "Fail Cloned Repository"'
                }
            }    
        }
        
        stage('Build Gradle Test') {
            
            steps {
                sh (script:'''
                    echo "Build Gradle Test Start"
                ''')

                dir('.') {
                    sh """
                    chmod +x gradlew
                    """
                }
                
                dir('.') {
                    sh """
                    ./gradlew clean build
                    """
                }
            }
            
            post {
                success { 
                    sh 'echo "Successfully Build Gradle Test"'
                }
                 failure {
                    sh 'echo "Fail Build Gradle Test"'
                }
            }    
        }
        
        stage('Docker Rm') {
            steps {
                sh 'echo "Docker Run Start"'
                sh """
                docker stop timecapsule
                docker rm -f timecapsule
                docker rmi -f timecapsule
                """
            }
            
            post {
                success { 
                    sh 'echo "Docker Rm Success"'
                }
                failure {
                    sh 'echo "Docker Rm Fail"'
                }
            }
        }
        
        stage('Bulid Docker Image') {
            steps {
                sh 'echo " Image Bulid Start"'
                sh """
                docker build -t timecapsule .
                """
            }
            
            post {
                success {
                    sh 'echo "Bulid Docker Image Success"'
                }

                failure {
                    sh 'echo "Bulid Docker Image Fail"'
                }
            }
        }
        
        stage('Docker Run') {
            steps {
                sh 'echo "Docker Run Start"'
                sh """
                docker run \
                  --name=timecapsule \
                  -p 80:8080 \
                  -v /docker_projects/aaaaa/volumes/gen:/gen \
                  --restart unless-stopped \
                  -e TZ=Asia/Seoul \
                  -d \
                  timecapsule
                """
            }
            
            post {
                success {
                    sh 'echo "Docker Run Success"'
                }

                failure {
                    sh 'echo "Docker Run Fail"'
                }
            }
        }
    }
}

 

7) ACG에서 80 포트번호 열기 

 

8) 공인아이피주소/test1 -> controller에 /test1 Mapping 후 Git push 하고 들어가면 정상 작동 됨 !


 

젠킨스를 도커에 설치했는데 서버가 안 뜬다면? 방화벽 문제 

 

1) ACG 클릭 

 

2) 접근소스와 허용포트 입력후 추가

 

 


[ 도커에 설치한 Jenkins로 들어가는 법 ]

root@~~ -> 🩷 docker exec -it 4767d5ebabf4 /bin/bash

 


여기서 우리는 CentOS대신 우분투 가상머신 사용

 

728x90