Yooniverse

Jenkins - REST API를 이용한 Job 복사

Tue, 23 Apr 2024 00:00:00 +0900

개요

사용 방법
- 원본 Job 설정 파일 가져오기
- Job 생성

사용 방법

원본 Job 설정 파일 가져오기

curl -X GET http://[JENKINS_URL]/job/[JOB_NAME]/config.xml -u [USER_NAME]:[API_TOKEN] > config.xml

[JENKINS_URL] Jenkins URL
[JOB_NAME] 복사할 Job Name
[USERNAME] 로그인 시 사용할 계정(admin)
[API_TOKEN] API token

Job 생성

curl -X POST -H "Content-Type: application/xml" -d @config.xml "http://[JENKINS_URL]/createItem?name=[NEW_JOB_NAME]" -u [USER_NAME]:[API_TOKEN]

[JENKINS_URL] Jenkins URL
[NEW_JOB_NAME] 생성할 Job Name
[USER_NAME] 로그인 시 사용할 계정(admin)
[API_TOKEN] API token

Jenkins - Matrix Authorization Strategy Plugin

Tue, 23 Apr 2024 00:00:00 +0900

개요

Use Case
- 사용자별 Use Case
- 프로젝트별 Use Case
사용 목적

Use Case

사용자별/프로젝트별 권한을 설정하여 관리한다.

사용자별 Use Case

Matrix Authorization Strategy 플러그인 설치
Jenkins 관리 > Configure Global Security > Authorization > Matrix-based security 선택
Add user > 권한 설정

프로젝트별 Use Case

Matrix Authorization Strategy 플러그인 설치
Jenkins 관리 > Configure Global Security > Authorization > Matrix-based security 선택
Item 구성 > General > Enable project-based security 체크박스 선택
Add user > 권한 설정

사용 목적

권한은 기본적으로 전역으로 구성되어 있거나 모든 상위 목록에서 상속된다. 하지만 Matrix Authorization Plugin을 사용하게 되면 각 항목 또는 사용자들에 대한 권한을 독립적으로 구성이 가능하다.

Jenkins - 설치 방법

Tue, 23 Apr 2024 00:00:00 +0900

환경

OS: Window
VM: Virtual Box
VM 내 OS: Linux(Ubuntu)

저장소 키 가져오기

sudo wget -O /usr/share/keyrings/jenkins-keyring.asc https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key

Jenkins의 패키지 저장소 항목 추가

echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
    https://pkg.jenkins.io/debian-stable binary/ | sudo tee \
    /etc/apt/sources.list.d/jenkins.list > /dev/null

sudo apt update

Java 패키지 버전 설치

sudo apt install fontconfig openjdk-11-jre

sudo apt update

Jenkins 설치

특정 버전 설치 시 [VERSION] 내에 원하는 버전 입력

sudo apt install jenkins=[VERSION]

sudo apt update

Jenkins 자동 실행 설정

sudo systemctl enable --now jenkins

Jenkins 서비스 시작

sudo systemctl start jenkins

포트 번호 허용

기본 포트 번호: 8080

sudo ufw allow 8080

Jenkins 접속

localhost:8080
initialAdminPassword 위치 확인 후 복사 및 붙여넣기

참고 링크

클릭 시 이동

Groovy Script 예시

Thu, 09 Nov 2023 00:00:00 +0900

개요

개요
오래된 스크립트
- Jenkins의 로컬 복사본 시작
Scriptler 플러그인 Groovy Script

오래된 스크립트

Jenkins 소스코드에 직접 액세스하는 Groovy 스크립트 특성으로 인해 Script Console Script는 Jenkins 소스코드에서 쉽게 구식이 된다. Jenkins 코어 또는 Jenkins 플러그인의 공용 메소드 및 인터페이스가 변경되었으므로 스크립트를 실행하고 예외를 받는 것이 가능합니다.

Jenkins의 로컬 복사본 시작

export JENKINS_HOME="./my_jenkins_home"
java -jar jenkins.war

Jenkins 중지 시: Ctrl + C
프로덕션 Jenkins 인스턴스에서 Script Console 예제를 시도하는 것은 권장 X
Jenkins용 Groovy 스크립트 예시
CloudBees 젠킨스 스트립트 저장소
scriptler/Jenkins CI > jenkins-scripts 저장소 (Scriptler 플러그인용 스크립트)
Sam Gleske의 jenkins-script-console-scripts 저장소
Sam Gleske의 jenkins-bootstrap-shared 저장소는 scrips/디렉토리 아래에 존재

Scriptler 플러그인 Groovy Script

- Jenkins 서버의 모든 작업에 대해 Chuck Norris 플러그인 활성화

import jenkins.model.*


for(item in Jenkins.instance.items) {
     println("job $item.name")
     item.publishersList.replace(new  hudson.plugins.chucknorris.CordellWalkerRecorder());
}

모든 작업에 알림 플러그인 추가

for (item in Hudson.instance.items) { 
  notification = item.properties.find { it.getKey().getClass() == com.tikal.hudson.plugins.notification.HudsonNotificationPropertyDescriptor }    
  if (notification != null) {
    continue
  }

  println(">>>>>>>> Adding notification plugin to $item.name")   
  protocol = com.tikal.hudson.plugins.notification.Protocol.UDP
  endpoint = new com.tikal.hudson.plugins.notification.Endpoint(protocol, '172.16.24.204:11337')
  notification = new com.tikal.hudson.plugins.notification.HudsonNotificationProperty([endpoint])

  item.addProperty(notification)
  item.save()
}

서버의 모든 작업에서 옵션 활성화

import hudson.model.*
import hudson.maven.*
import hudson.tasks.*

for(item in Hudson.instance.items) {
  println("job $item.name")
  hasClaim = false;
  for(p in item.publishers )
  {
    if(p instanceof hudson.plugins.claim.ClaimPublisher)
    {
      hasClaim = true;
    }
  }
  if(!hasClaim)
  {
    println(">>>>>>>> Adding claim right to $item.name")
    item.getPublishersList().add(new  hudson.plugins.claim.ClaimPublisher() );
    item.save()
  }
}

Hg에서 체크아웃된 branch 일괄 업데이트

def oldBranch = "NAME_OF_OLD_BRANCH" // update this
def newBranch = "NAME_OF_NEW_BRANCH" // update this
def jobNamePattern = "YourRegExPattern" // update this
def freeStyleJobs = hudson.model.Hudson.instance.getItems(hudson.model.FreeStyleProject.class)
for (job in freeStyleJobs)
{
  def oldScm = job.getScm()
  if (oldScm.getType().indexOf("Mercurial") 1 && job.name.matches(jobNamePattern))
  {
    if (oldScm.getBranch().equals(oldBranch))
    {
      print "Job '${job.name}' has branch '${oldBranch}' and will be updated to '${newBranch}'"
      // uncomment the next two lines to actually perform the operation. Else it simulates a dry-run
      //def newHgSCM = new  hudson.plugins.mercurial.MercurialSCM(oldScm.getInstallation(),  oldScm.getSource(), newBranch, oldScm.getModules(), oldScm.getSubdir(),  oldScm.getBrowser(), oldScm.isClean())
      //job.setScm(newHgSCM)      println "[OK]"  
    } else if (oldScm.getBranch().equals(newBranch))
    {
      println "Job '${job.name}' already is on branch '${newBranch}'"  
    } else
    {
      println "Job '${job.name}' is on branch '${oldScm.getBranch()}' and will not be updated" 
    }
  }
}

프로젝트 대량 이름 바꾸기

import hudson.model.*

disableChildren(Hudson.instance.items)

def disableChildren(items) {
  for (item in items) {
    if (item.class.canonicalName != 'com.cloudbees.hudson.plugins.folder.Folder') {
	if (( m = item.name =~ /^(Findur.OpenComponent)(\..*)$/)){
          println(item.name)
          println m.group(1) + " " + m.group(2)
          newname = m[0][1] + 's' + m.group(2)
          item.renameTo(newname)
      }
    } else {
	disableChildren(((com.cloudbees.hudson.plugins.folder.Folder) item).getItems())
    }
  }
}

Freestyle 작업에 등록된 모든 Maven 작업을 찾아 JVM 옵션을 새 값으로 변경

import hudson.model.*
import hudson.maven.*
import hudson.tasks.*

def newJvmOptions="-Xshare:auto -Xms64m -Xmx512m -XX:MaxPermSize=256M"

// For each project
for(item in Hudson.instance.allItems) {
  if(item instanceof FreeStyleProject) {
    println("JOB : "+item.name);
    // Find current recipients defined in project
    println(">FREESTYLE PROJECT");
    for (builder in item.builders){
      println(">> "+builder);
      if (builder instanceof Maven) {
        println(">>MAVEN BUILDER");
        println(">>TARGETS : "+builder.targets);
        println(">>NAME : "+builder.mavenName);
        println(">>POM : "+builder.pom);
        // .properties is overridden by groovy
        println(">>PROPERTIES : "+builder.@properties);
        println(">>JVM-OPTIONS : "+builder.jvmOptions);
        println(">>USE PRIVATE REPO : "+builder.usePrivateRepository);
        println(">>USER SETTINGS : "+builder.settings);
        println(">>GLOBAL SETTINGS : "+builder.globalSettings);
        def newBuilder = new Maven(builder.targets,builder.mavenName,builder.pom,builder.@properties,newJvmOptions,builder.usePrivateRepository,builder.settings,builder.globalSettings);
        item.buildersList.replace(newBuilder);
      }
    }
    println("\n=======\n");
  }
}

SSH 구성을 통한 게시 변경

import java.util.*
import hudson.model.*
import hudson.maven.*
import hudson.maven.reporters.*
import hudson.matrix.*
import hudson.tasks.*
import hudson.util.DescribableList
import jenkins.plugins.publish_over_ssh.*
import jenkins.plugins.publish_over.*

hudson.model.Hudson.instance.items.findAll{job -> job.isBuildable() }.each{
job -> 

  if(job instanceof FreeStyleProject) {
    for (builder in job.builders){
      if(builder instanceof BapSshBuilderPlugin) {
        ArrayList<BapPublisher> publishers = builder.delegate.delegate.publishers
        
        for(publisher in publishers) {
          if (publisher.configName == "bad-server") {
            println "Changing job: ${job.name}"
            publisher.configName = "good-server"
          }
        }
      }
    }
  }
}

21:00~07:00 및 주말에 비활성화

import hudson.model.*
import hudson.triggers.*


TriggerDescriptor SCM_TRIGGER_DESCRIPTOR = Hudson.instance.getDescriptorOrDie(SCMTrigger.class)
assert SCM_TRIGGER_DESCRIPTOR != null;

for(item in Hudson.instance.items)
{
  println("Working on project <$item.name>")
  
  def trigger = item.getTriggers().get(SCM_TRIGGER_DESCRIPTOR)
  if(trigger != null && trigger instanceof SCMTrigger)
  {
    print("> $trigger.spec")
    String[] parts = trigger.spec.split(" ");
    
    //Do wanted modifs
    if(parts[1] == "*" )
    {
      parts[1] = "7-21"
    }
    if(parts[4] == "*")
    {
      parts[4] = "1-5"
    }
    //end modifs
    
    StringBuilder newSpec = new StringBuilder();
    for(p in parts)
    {
      newSpec.append(p+" ");
    }
    
    println(" => $newSpec");

    def newTrigger = new SCMTrigger(newSpec.toString())
    newTrigger.job = item

    item.removeTrigger(SCM_TRIGGER_DESCRIPTOR)
    item.addTrigger(newTrigger)
  }
  else
  {
    println "> Nothing to do"
  }
}

SVN 경로의 버전 번호 변경

import hudson.scm.*
//import hudson.model.*

/** Old Version for the SVN-Path */
oldVersion  = "1.28"

/** New Version for the SVN-Path */
newVersion  = "1.29"

/** Path to the SVN-Repo containing with the following */
svnpath = "repo/testjob"

 /** Jobs containing with */
jobs = "testjob"

/** Should we override existing values? */
overrideExistingValues = false

/** Display Konfiguration */
println "### Overwrite SVN-Version ###"
println "oldVersion:     " + oldVersion
println "newVersion:     " + newVersion
println "Jobs with:      " + jobs
println "Repo_with_Path: " + svnpath


// ----- Do the work. -----

// Access to the Hudson Singleton
hudsonInstance = hudson.model.Hudson.instance

// Retrieve all Jobs which starts with -jobs-
allItems = hudsonInstance.items
chosenJobs = allItems.findAll{job -> job.name.contains(jobs)}

// Table header
col1 = "Job".center(35)
col2 = "OldPath".center(120)
col3 = "NewPath".center(120)
header = "$col1 | $col2 | $col3"
line = header.replaceAll("[Change Version-Number in SVN-path^|]", "-").replaceAll("\\|", "+")

println line
println header
println line

// Do work and create the result table
chosenJobs.each { job ->
 if(!(job instanceof hudson.model.ExternalJob)) {
   // No SCM-Configuration possible for External Jobs!
   if (job.scm instanceof SubversionSCM) {
     // Job has a SubversionSCM-Konfiguration
     def oldSvnPath = [][]
     def newSvnPath = [][]
     job.scm.locations.each{
       //For every Subversion-Location
       if (it.remote.contains(svnpath)) {
         //SVN-Path contains the given Path
         oldRemote = it.remote.padRight(119)
         jobname  = job.name.padRight(35)
         newRemote = it.remote
         if (it.remote.contains(oldVersion)) {
           //SVN-Path contains the old Version, which should be replaced
           newRemote = it.remote.replaceAll(/$oldVersion/,"$newVersion")  //Replace
           //Build new SVN-Location (it is not possible to change a value in the existing configuration)
           newSvnPath.add(new hudson.scm.SubversionSCM.ModuleLocation(newRemote,it.local))

           //For Visualisation of the changed Value
           newRemote = newRemote.padRight(120,"<")
           // Output Result for this Subversion-Location
           println "$jobname | $oldRemote ]> $newRemote"
         } else {
           //Visualisation of value which is not changed
           newRemote = newRemote.padRight(120)
           // Output Result for this Subversion-Location
           println "$jobname | $oldRemote  | $newRemote"
         }
       }

     }
     // Every Location was checked. Building new SVN-Configuration with the new SVN-Locations
     newscm = new hudson.scm.SubversionSCM(newSvnPath, job.scm.workspaceUpdater, job.scm.browser,
     job.scm.excludedRegions, job.scm.excludedUsers, job.scm.excludedRevprop, job.scm.excludedCommitMessages, job.scm.includedRegions)
     if (overrideExistingValues){
       // Only write values, when overrideExistingValues is true
       job.scm = newscm;
     }
     println line
     //Job is done
   }
 }
}
println line
//done

특정 보기에 속한 모든 프로젝트를 열거하고 복제

import hudson.model.*
 
def str_view = "MyProduct_Release_1.0"
def str_search = "Rel_1.0"
def str_replace = "Rel_1.1"
 
def view = Hudson.instance.getView(str_view)
 
//copy all projects of a view
for(item in view.getItems())
{

  //create the new project name
  newName = item.getName().replace(str_search, str_replace)

 
  // copy the job, disable and save it
  def job = Hudson.instance.copy(item, newName)
  job.disabled = true
  job.save()
  
  // update the workspace to avoid having two projects point to the same location
  AbstractProject project = job
  def new_workspace = project.getCustomWorkspace().replace(str_search, str_replace)
  project.setCustomWorkspace(new_workspace)
  project.save()
  
  println(" $item.name copied as $newName")

}

모든 프로젝트의 메일 알림을 Mail-Ext 게시자 플러그인으로 대체, 기존 수신자 재사용

import hudson.model.*
 
def str_view = "MyProduct_Release_1.0"
def str_search = "Rel_1.0"
def str_replace = "Rel_1.1"
 
def view = Hudson.instance.getView(str_view)
 
//copy all projects of a view
for(item in view.getItems())
{

  //create the new project name
  newName = item.getName().replace(str_search, str_replace)

 
  // copy the job, disable and save it
  def job = Hudson.instance.copy(item, newName)
  job.disabled = true
  job.save()
  
  // update the workspace to avoid having two projects point to the same location
  AbstractProject project = job
  def new_workspace = project.getCustomWorkspace().replace(str_search, str_replace)
  project.setCustomWorkspace(new_workspace)
  project.save()
  
  println(" $item.name copied as $newName")

}

빌드 후 작업 공간 파일 디렉토리에 남아있는 모든 tml 파일 삭제

import hudson.model.*

def counter = 0

// Create a ref for closure
def delClos

// Define closure
delClos = {
	it.eachDir( delClos );
	if(it.getName().contains("workspace-files")) {
		it.eachFile {
			if(it.getName().endsWith(".tmp") ){
				println "Deleting file ${it.canonicalPath}";
				it.delete()
				counter++;
			}
		}
	}
}

// Apply closure
for(item in Hudson.instance.items) {
	println "Applying on " + item.rootDir
	delClos( item.rootDir )
}
println counter + " files deleted"

비활성화된 모든 작업에 대한 작업 공간 삭제

//michaeldkfowler
import jenkins.model.*
Jenkins.instance.getAllItems(AbstractProject.class)
.findAll {it.disabled}
    .each {
      println("Wiping workspace for "+it.fullName)
      it.doDoWipeOutWorkspace()
    }

Jenkins 서버의 모든 작업을 비활성화

import hudson.model.*


disableChildren(Hudson.instance.items)

def disableChildren(items) {
  for (item in items) {
    if (item.class.canonicalName == 'com.cloudbees.hudson.plugins.folder.Folder') {
        disableChildren(((com.cloudbees.hudson.plugins.folder.Folder) item).getItems())
    } else if (item.class.canonicalName != 'org.jenkinsci.plugins.workflow.job.WorkflowJob') {
      item.disabled=true
      item.save()
      println(item.name)
    }
  }
}

모든 에이전트 노드에 대한 정보 표시

for (aSlave in hudson.model.Hudson.instance.slaves) {
  println('====================');
  println('Name: ' + aSlave.name);
  println('getLabelString: ' + aSlave.getLabelString());
  println('getNumExectutors: ' + aSlave.getNumExecutors());
  println('getRemoteFS: ' + aSlave.getRemoteFS());
  println('getMode: ' + aSlave.getMode());
  println('getRootPath: ' + aSlave.getRootPath());
  println('getDescriptor: ' + aSlave.getDescriptor());
  println('getComputer: ' + aSlave.getComputer());
  println('\tcomputer.isAcceptingTasks: ' + aSlave.getComputer().isAcceptingTasks());
  println('\tcomputer.isLaunchSupported: ' + aSlave.getComputer().isLaunchSupported());
  println('\tcomputer.getConnectTime: ' + aSlave.getComputer().getConnectTime());
  println('\tcomputer.getDemandStartMilliseconds: ' + aSlave.getComputer().getDemandStartMilliseconds());
  println('\tcomputer.isOffline: ' + aSlave.getComputer().isOffline());
  println('\tcomputer.countBusy: ' + aSlave.getComputer().countBusy());
  //if (aSlave.name == 'NAME OF NODE TO DELETE') {
  //  println('Shutting down node!!!!');
  //  aSlave.getComputer().setTemporarilyOffline(true,null);
  //  aSlave.getComputer().doDoDelete();
  //}
  println('\tcomputer.getLog: ' + aSlave.getComputer().getLog());
  println('\tcomputer.getBuilds: ' + aSlave.getComputer().getBuilds());
}

모든 작업에 대한 매개변수 표시

import hudson.model.*

for(item in Hudson.instance.items) {
  prop = item.getProperty(ParametersDefinitionProperty.class)
  if(prop != null) {
    println("--- Parameters for " + item.name + " ---")
    for(param in prop.getParameterDefinitions()) {
      try {
        println(param.name + " " + param.defaultValue)
      }
      catch(Exception e) {
        println(param.name)
      }
    }
    println()
  }
}

사용하는 빌드 단계별로 작업 그룹 표시

import hudson.model.*
import hudson.tasks.*

//All the projects on which we can apply the getBuilders method
def allProjects = Hudson.instance.items.findAll{ it instanceof Project }

//All the registered build steps in the current Jenkins Instance
def allBuilders = Builder.all()

//Group the projects by the build steps used
def projectsGroupByBuildSteps = allBuilders.inject([:]){
   map, builder ->   
   map[builder.clazz.name] = allProjects.findAll{it.builders.any{ it.class.name.contains(builder.clazz.name)}}.collect{it.name}
   map
}

//presentation
projectsGroupByBuildSteps.each{
   println """--- $it.key ---
   \t$it.value\n"""
}

모든 작업에 대해 알림에 사용되는 메일 수신자 목록 표시

import hudson.plugins.emailext.*
import hudson.model.*
import hudson.maven.*
import hudson.maven.reporters.*
import hudson.tasks.*

// For each project
for(item in Hudson.instance.items) {
 println("JOB : "+item.name);
 // Find current recipients defined in project
 if(!(item instanceof ExternalJob)) {
 if(item instanceof MavenModuleSet) {
 println(">MAVEN MODULE SET");
 // Search for Maven Mailer Reporter
 println(">>Reporters");
 for(reporter in item.reporters) {
 if(reporter instanceof MavenMailer) {
 println(">>> reporter : "+reporter+" : "+reporter.recipients);
 }
 }
 } else
 if(item instanceof FreeStyleProject) {
 println(">FREESTYLE PROJECT");
 }
 println(">>Publishers");
 for(publisher in item.publishersList) {
 // Search for default Mailer Publisher (doesn't exist for Maven projects)
 if(publisher instanceof Mailer) {
 println(">>> publisher : "+publisher+" : "+publisher.recipients);
 } else
 // Or for Extended Email Publisher
 if(publisher instanceof ExtendedEmailPublisher) {
 println(">>> publisher : "+publisher+" : "+publisher.recipientList);
 }
 }
 } else {
 println("External Jobs cannot have MailNotificationsRecipients")
 }
 println("\n=======\n");
}

Jenkins는 모니터를 사용하여 다양한 동작을 검증. 하나를 닫으면 Jenkin는 다시 활성화하도록 제안하지 않음. 스크립트 사용 시 모든 모니터 상태 확인 후 재활성화 가능

hudson.model.Hudson.instance.administrativeMonitors.each{
    println "* Monitor : "+it.id
    println "** Enabled : "+it.enabled
    println "** Activated : "+it.activated
    println "========="
}

모든 작업에 대한 타이머 트리거 표시

import hudson.model.*
import hudson.triggers.*

for(item in Hudson.instance.items) {
	for(trigger in item.triggers.values()) {
		if(trigger instanceof TimerTrigger) {
			println("--- Timer trigger for " + item.name + " ---")
			println(trigger.spec + '\n')
		}
	}
}

모든 에이전트에서 Jenkins 도구 위치 표시

import hudson.model.*
import hudson.node_monitors.*
import hudson.slaves.*
import java.util.concurrent.*
import hudson.tools.ToolDescriptor;
import hudson.tools.ToolInstallation;
jenkins = Hudson.instance
  
TaskListener log;
  
def getEnviron(computer) {
   def env
   def thread = Thread.start("Getting env from ${computer.name}", { env = computer.environment })
   thread.join(2000)
   if (thread.isAlive()) thread.interrupt()
   env
}

def slaveAccessible(computer) {
    getEnviron(computer)?.get('PATH') != null
}

for (aSlave in jenkins.slaves) {
   def computer = aSlave.computer
  
     println "Checking computer ${computer.name}:"
     def isOK = (slaveAccessible(computer) && !computer.offline)
     if (isOK) {

     
        for (ToolDescriptor<?> desc : ToolInstallation.all()) {
            for (ToolInstallation inst : desc.getInstallations()) {
                println ('\tTool Name: ' + inst.getName());
                println ('\t\tTool Home: ' + inst.translateFor(aSlave,log));
            }  
 }  
    } else {
        println "  ERROR: can't get PATH from slave: node is offline."
    }       
}

서버의 모든 작업에서 타임스탬퍼 플러그인 활성화

for (item in Hudson.instance.items) {
  println("\njob: $item.name")
  hasTimestamper = false;
  item.buildWrappersList.each {
    if (it instanceof hudson.plugins.timestamper.TimestamperBuildWrapper) {
      hasTimestamper = true;
    }
  }
  if (!hasTimestamper) {
    println(">>>>>>>> Adding timestamper right to $item.name")
    item.buildWrappersList.add(new hudson.plugins.timestamper.TimestamperBuildWrapper());
    item.save()
  }
}

실패한 모든 작업 목록 표시

// Get the list of failed jobs
activeJobs = hudson.model.Hudson.instance.items.findAll{job -> job.isBuildable()}
failedRuns = activeJobs.findAll{job -> job.lastBuild != null && job.lastBuild.result == hudson.model.Result.FAILURE}
// Do something with them - e.g. listing them
failedRuns.each{run -> println(run.name)}

> Addon: Restart

startServer = "admin computer"
startNote   = "bulk start"
cause = new hudson.model.Cause.RemoteCause(startServer, startNote)
failedRuns.each{run -> run.scheduleBuild(cause)}

현재 실행 중이며 N초 이상 실행된 빌드 찾기

int MAX_ALLOWED_DURATION_IN_SECONDS = 3600 * 6 // 6 hours


  def busyExecutors = Jenkins.instance.computers
                                .collect { 
                                  c -> c.executors.findAll { it.isBusy() }
                                }
                                .flatten() // reminder: transforms list(list(executor)) into list(executor)

def ok = true

println "Busy Executors list"
busyExecutors.each { e -> 
  println e ; 
  int durationInSeconds = (System.currentTimeMillis() - e.executable.getTimeInMillis())/1000.0
  
  if(durationInSeconds > MAX_ALLOWED_DURATION_IN_SECONDS )
  {
    ok = false;
  }
  println "\t duration=$durationInSeconds"
  println "" 
}

println "Done"

return ok

빌드 권한이 있는 사용자 및 그룹에 취소 권한 부여

import hudson.security.*
import jenkins.security.*
import jenkins.model.Jenkins


boolean dryrun=true

if (dryrun) {
  println ''.center(100,'!')
  println 'This is a dryrun, nothing will be changed'.center(100,'!')
  println 'Change this line: boolean dryrun=false to boolean dryrun=true to make the real change'.center(100,'!')
  println ''.center(100,'!')
}

switch (Jenkins.instance.authorizationStrategy){
  case GlobalMatrixAuthorizationStrategy:
    println '\nGlobal Matrix Strategy defined. Fixing Cancel permissions...\n'
    def sids = Jenkins.instance.authorizationStrategy.getAllSIDs().plus('anonymous')
    for (sid in sids){
      if (Jenkins.instance.authorizationStrategy.hasPermission(sid,hudson.model.Item.BUILD)){
        println '----'+sid+' has Build permission and Cancel permission will be add'
        if (!dryrun) Jenkins.instance.authorizationStrategy.add(hudson.model.Item.CANCEL,sid)
      }
    }
    if (!dryrun) Jenkins.instance.save()
  case ProjectMatrixAuthorizationStrategy:
    println '\nProject Matrix Strategy defined. fixing Cancel permissions...\n'
    def jobs = Jenkins.instance.items
    jobs.each {
      println it.name.center(80,'-')
      def authorizationMatrixProperty = it.getProperty(AuthorizationMatrixProperty.class)
      def sids = authorizationMatrixProperty?.getAllSIDs().plus('anonymous')
      for (sid in sids){
        if (authorizationMatrixProperty?.hasPermission(sid,hudson.model.Item.BUILD)){
          println ''+sid+' has Build permission and Cancel permission will be add'
          if (!dryrun) authorizationMatrixProperty?.add(hudson.model.Item.CANCEL,sid)
        }
      }
      if (!dryrun) it.save()
    }
    break
  default:
    println "No permission need to be mofdified gloabally"
    break
}

return

Jenkins HTTP 세션 무효화

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionActivationListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import net.bull.javamelody.*;
  
def chuck = SessionListener.newInstance();
println ("Session Info: ");
println chuck.getAllSessionsInformations();
sessionCount = chuck.getSessionCount();
println ("Number of Session: " + sessionCount);
maxSessionCount = 70;
if ( sessionCount > maxSessionCount ) {
          println ("Open Session " + sessionCount + " more than " + maxSessionCount);
          println "Invalidating...";
          chuck.invalidateAllSessions();
}

수동으로 연결이 끊어지지 않은 경우 오프라인 노드를 모니터링 후 다시 시작

//michaeldkfowler
import jenkins.model.*
Jenkins.instance.getAllItems(AbstractProject.class)
.findAll { it.logRotator }
    .each {
      it.logRotator.perform(it)
    }

모니터링 플러그인 사용 시 http 세션, 스레드, 메모리, JVM 또는 MBean에 대한 데이터를 표시하는 여러 스크립트

매개변수화된 시스템 Groovy Script

import hudson.model.*

// get current thread / Executor
def thr = Thread.currentThread()
// get current build
def build = thr?.executable


// get parameters
def parameters = build?.actions.find{ it instanceof ParametersAction }?.parameters
parameters.each {
   println "parameter ${it.name}:"
   println it.dump()
   println "-" * 80
}


// ... or if you want the parameter by name ...
def hardcoded_param = "FOOBAR"
def resolver = build.buildVariableResolver
def hardcoded_param_value = resolver.resolve(hardcoded_param)


println "param ${hardcoded_param} value : ${hardcoded_param_value}"

Maven release build에서 사용자 이름 미리 선택

import hudson.model.*
import hudson.maven.*
import hudson.tasks.*
import org.jvnet.hudson.plugins.m2release.*

for(item in Hudson.instance.items) {
  if (item instanceof MavenModuleSet)
  {
    println("\njob $item.name ");
    rw = item.getBuildWrappers().get(M2ReleaseBuildWrapper.class);
    if (rw == null)
    {
      println("release build not configured");
    }
    else 
    {
     println("append Username: "+rw.isSelectAppendHudsonUsername())
     rw.setSelectAppendHudsonUsername(true)
     item.save()
    }
  }  
}

자격 증명 및 해당 ID 목록 인쇄

  def creds = com.cloudbees.plugins.credentials.CredentialsProvider.lookupCredentials(
      com.cloudbees.plugins.credentials.common.StandardUsernameCredentials.class,
      Jenkins.instance,
      null,
      null
  );
  for (c in creds) {
       println(c.id + ": " + c.description)
  }

Maven 작업에서 비활성화된 모든 모듈 제거

Jenkins.instance.getAllItems(hudson.maven.MavenModuleSet.class).findAll{job -> job.isBuildable()}.each{
job ->
  job.getDisabledModules(true).each{module -> module.delete()} 
  println(job.name+" cleaned")
}

Artifact Deployer 플러그인이 각 빌드에 대해 불필요하게 저장한 배포된 Artifact 목록 제거

import hudson.model.*

hudsonInstance = hudson.model.Hudson.instance
allItems = hudsonInstance.items

// Iterate over all jobs and find the ones that have a org.jenkinsci.plugins.artifactdeployer.DeployedArtifacts
// as an action.

def jobCounter = 0;
def totalBuildCounter = 0;

for (job in allItems) {
  def buildCounter = 0;
  for (build in job.getBuilds()) {
    // It is possible for a build to have multiple actions
    def adActions = build.getActions(org.jenkinsci.plugins.artifactdeployer.DeployedArtifacts.class)
    if (adActions != null && !adActions.isEmpty()) {
      for (action in adActions) {
        build.actions.remove(action)
      }
      build.save();
      buildCounter++;
    }
  }
  if (buildCounter > 0) {
      println("Job: " + job.name + " cleaned " + buildCounter + " builds");
      jobCounter++;
      totalBuildCounter += buildCounter;
  }  
}

println("Cleaned " + jobCounter + " jobs and a total of " + totalBuildCounter + " builds");

Git 플러그인이 각 빌드에 대해 불필요하게 저장한 BuildsByBranch의 정적 목록 제거

모든 저장소에 대한 사용자 정의 설정으로 GitBlitRepositoryBrowser 설정

import hudson.model.*
import hudson.triggers.*
import hudson.plugins.git.browser.GitBlitRepositoryBrowser

// you might want to change here
def url = 'https://mygitblitserver/gitblit/'
def i = 0
for(item in Hudson.instance.items) {
  def scm = item.scm
  if((scm instanceof hudson.plugins.git.GitSCM) && !(scm.browser instanceof GitBlitRepositoryBrowser)) {
    println('##########')
    println(scm.dump())
    // you might want to change here
    def match = scm.userRemoteConfigs =~ /\/spu\/test\/git\/(.*?.git)/
    if(match) {
      i++
      def projectName = match[0][1]
      println projectName
      scm.browser = new GitBlitRepositoryBrowser(url, projectName)
    }
  }
}
println("$i projects updated")

빌드 후 단계를 설치하고 활성화하여 배포 목표가 있는 모든 Maven 작업 업데이트

import java.util.*
import hudson.model.*
import hudson.maven.*
import hudson.maven.reporters.*
import hudson.matrix.*
import hudson.tasks.*

hudson.model.Hudson.instance.items.findAll{job -> job.isBuildable() && job instanceof MavenModuleSet}.each {
job -> 
  println(job.name)
  if (job.goals.indexOf("deploy")>0) {
    println("* Must update goals (deploy -> install) : " + job.goals)
    def newGoals = job.goals.replaceAll("deploy", "install");
    println("* New goals : " + newGoals)
    // Comment the 3 following lines for a first run to check goals modifications without modifying anything
    job.goals = newGoals
    job.archivingDisabled = false // It is necessary to archive artifacts to deploy them after the build
    job.publishers.replace(new hudson.maven.RedeployPublisher(null, null, true, false));
    println("* Redeploy publisher added");
  } else {
    println("* This maven job doesn't deploy its artifacts");
  }
}

SVN 브라우저 업데이트

import hudson.model.*
import hudson.maven.*
import hudson.tasks.*
import hudson.scm.*
import hudson.scm.browsers.*

for(item in Hudson.instance.items) {
  hasClaim = false;
  if (item.scm instanceof SubversionSCM)
  {
      println("\njob $item.name")
      println(item.scm.browser);
      if (item.scm.browser instanceof Sventon2)
      {
        println(item.scm.browser.url);
        println(item.scm.browser.repositoryInstance);
      }
      else
      {
        // add the repo browser details.
        browser = new hudson.scm.browsers.Sventon2(new URL("http://...../"), ".....")

        // unfortunately can't just add a browser - need to create a new scm entry, which is complex...
        scm = new  SubversionSCM(Arrays.asList(item.scm.locations), item.scm.workspaceUpdater, browser, item.scm.excludedRegions, item.scm.excludedUsers, item.scm.excludedRevprop, item.scm.excludedCommitMessages, item.scm.includedRegions, item.scm.ignoreDirPropChanges)

        item.scm = scm
        item.save()
        println("Updated repo browser");
      }
  }
}

Jenkins 서버에 있는 모든 작업의 작업 공간 제거

import hudson.model.*
// For each project
for(item in Hudson.instance.items) {
  // check that job is not building
  if(!item.isBuilding()) {
    println("Wiping out workspace of job "+item.name)
    item.doDoWipeOutWorkspace()
  }
  else {
    println("Skipping job "+item.name+", currently building")
  }
}

모든 노드에 있는 특정 작업의 작업 공간 지우기

import hudson.model.*
// For each job
for (item in Hudson.instance.items)
{
  jobName = item.getFullDisplayName()
  // check that job is not building
  if (!item.isBuilding())
  {
    // TODO: Modify the following condition to select which jobs to affect
    if (jobName == "MyJob")
    {
      println("Wiping out workspaces of job " + jobName)
      customWorkspace = item.getCustomWorkspace()
      println("Custom workspace = " + customWorkspace)

      for (node in Hudson.getInstance().getNodes())
      {
        println("  Node: " + node.getDisplayName())
        workspacePath = node.getWorkspaceFor(item)
        if (workspacePath == null)
        {
          println("    Could not get workspace path")
        }
        else
        {
          if (customWorkspace != null)
          {
            workspacePath = node.getRootPath().child(customWorkspace)
          }

          pathAsString = workspacePath.getRemote()
          if (workspacePath.exists())
          {
            workspacePath.deleteRecursive()
            println("    Deleted from location " + pathAsString)
          }
          else
          {
            println("    Nothing to delete at " + pathAsString)
          }
        }
      }
    }
  }
  else
  {
    println("Skipping job " + jobName + ", currently building")
  }
}

Groovy 사용을 가능하게 하는 플러그인

Thu, 09 Nov 2023 00:00:00 +0900

개요

개요
구성 파일 제공자 플러그인
글로벌 포스트 스크립트 플러그인
Groovy 플러그인
Groovy Postbuild 플러그인
Groovy Remote Control 플러그인
Matrix Groovy Execution Strategy 플러그인
Scriptler 플러그인

구성 파일 제공자 플러그인

Jenkins UI를 통해 로드된 구성파일(ex. Maven, XML, Groovy, 사용자 정의 파일 등에 대한 settings.xml)을 제공하는 기능 추가
이 파일은 작업의 작업공간에 복사

글로벌 포스트 스크립트 플러그인

Jenkins가 관리하는 각 작업을 빌드 후에 글로벌로 구성된 Groovy Script 실행
동일한 Jenkins가 관리하는 다운스트림 작업을 트리거하거나 매개변수화된 작업에 전달된 매개변수를 기반으로 하는 원격 작업을 트리거하는 등 공유 매개변수 세트를 기반으로 작업을 수행해야 하는 경우

Groovy Postbuild 플러그인

Jenkins JVM에서 Groovy Script 실행
일부 조건 확인 후 빌드 결과 변경, 빌드 기록에서 빌드 옆에 배지를 표시하거나 빌드 요약 페이지에 정보 표시

Groovy Remote Control 플러그인

Groovy Remote Control 수신기를 제공하고 Jenkins에서 외부 애플리케이션 제어 가능하게 해

Matrix Groovy Execution Strategy 플러그인

매트릭스 프로젝트의 실행 순서와 유효한 조합을 결정

Scriptler 플러그인

Scriptler 사용 시 Groovy Script를 저장/편집하고 모든 노드에서 실행 가능

Jenkins Script Console

Sat, 04 Nov 2023 00:00:00 +0900

개요

개요
Jenkins Script Console
다중 컨텍스트
원격 액세스
제출할 스크립트 콘솔의 단축키
비디오 튜토리얼 및 추가 학습 자료

Jenkins Script Console

액세스는 권한에 따라 제어됨(Administer)
Jenkins 런타임에 대한 웹 기반 Groovy Shell
Groovy: 자바가 할 수 있는 거의 모든 작업을 수행할 수 있는 기능을 제공하는 언어
- Jenkins 컨트롤러 및 에이전트에서 하위 프로세스를 생성, 임의 명령 실행
- Jenkins 컨트롤러가 호스트에서 액세스할 수 있는 파일(ex. /etc/passwd:) 읽기 가능
- Jenkins 내 구성된 자격 증명 해독
Jenkins 인프라의 모든 부분에 영향을 주지 않도록 스크립트 콘솔을 실행할 수 있는 사용자(또는 관리자)를 중지하는 관리 제어 기능을 제공하지 않음
- 일반 Jenkins 사용자에게 스크립트 콘솔 액세스 권한을 부여하는 것은 기본적으로 Jenkins 내에서 관리자 권한을 부여하는 것과 동일
Jenkins 설정 구성 가능
- 보안을 비활성화, 보안 재구성, Jenkins 프로세스 외부에서 호스트 운영 체제의 백도어 열기 가능
- 많은 조직이 인프라에서 Jenkins를 중요하게 생각하기 때문에 공격자가 노력하지 않아도 인프라 내에서 수평으로 이동 가능하기 때문에 중요함
원래 Jenkins 개발자를 위한 디버깅 인터페이스로 의도되었지만 이후 Jenkins 관리자가 Jenkins를 구성하고 Jenkins 런타임 문제를 디버깅하는 데 사용하는 인터페이스로 성장했기 때문에 매우 강력
Jenkins Script Console이 제공하는 기능으로 인해 Jenkins와 해당 에이전트는 root 사용자(Linux) 또는 다른 OS의 시스템 관리자로 실행되어서는 안 됨

다중 컨텍스트

Jenkins Script Console은 컨트롤러나 구성된 에이전트에서 실행 가능

컨트롤러에서 스크립트 콘솔 실행

Jenkins 관리 > 스크립트 콘솔 접근 가능
/script 또는 Jenkins 인스턴스의 하위 URL 방문

에이전트에서 스크립트 콘솔 실행

Jenkins 관리 > 노드 관리 방문
상태 페이지를 보려면 노드 선택
왼쪽 메뉴에는 해당 특정 에이전트의 “스크립트 콘솔”을 열 수 있는 메뉴 항목 존재

에이전트의 컨트롤러 스크립트 콘솔에서 스크립트 실행

개별 에이전트의 컨트롤러 스크립트 콘솔에서 스크립트 실행 가능
마스터 스크립트 콘솔의 에이전트에서 스크립트 실행

// 예시

import hudson.util.RemotingDiagnostics
import jenkins.model.Jenkins

String agentName = 'your agent name'
//groovy script you want executed on an agent
groovy_script = '''
println System.getenv("PATH")
println "uname -a".execute().text
'''.trim()

String result
Jenkins.instance.slaves.find { agent ->
    agent.name == agentName
}.with { agent ->
    result = RemotingDiagnostics.executeGroovy(groovy_script, agent.channel)
}
println result

파일 읽기 및 쓰기

컨트롤러 스크립트 콘솔을 통해 컨트롤러나 에이전트에서 직접 파일을 읽고 쓰기 가능
Jenkins 컨트롤러에 파일 쓰기

new File('/tmp/file.txt').withWriter('UTF-8') { writer ->
    try {
        writer << 'hello world\n'
    } finally {
        writer.close()
    }
}

Jenkins 컨트롤러에서 파일 읽기

new File('/tmp/file.txt').text

에이전트 채널을 통해 에이전트에 파일 쓰기

import hudson.FilePath
import hudson.remoting.Channel
import jenkins.model.Jenkins

String agentName = 'some-agent'
String filePath = '/tmp/file.txt'

Channel agentChannel = Jenkins.instance.slaves.find { agent ->
    agent.name == agentName
}.channel

new FilePath(agentChannel, filePath).write().with { os ->
    try {
        os << 'hello world\n'
    } finally {
        os.close()
    }
}

에이전트 채널을 통해 에이전트에서 파일 읽기

import hudson.FilePath
import hudson.remoting.Channel
import jenkins.model.Jenkins

import java.io.BufferedReader
import java.io.InputStreamReader
import java.nio.charset.StandardCharsets
import java.util.stream.Collectors

String agentName = 'some-agent'
String filePath = '/tmp/file.txt'

Channel agentChannel = Jenkins.instance.slaves.find { agent ->
    agent.name == agentName
}.channel

String fileContents = ''
new FilePath(agentChannel, filePath).read().with { is ->
    try {
        fileContents = new BufferedReader(
            new InputStreamReader(is, StandardCharsets.UTF_8))
                .lines()
                .collect(Collectors.joining("\n"))
    } finally {
        is.close()
    }
}

// print contents of the file from the agent
println '==='
println(fileContents)
println '==='

원격 액세스

Jenkins 관리자는 HTTP POST 요청을 /script/url 또는 /scriptText/.

Bash를 통한 curl 예제

curl -d "script=<your_script_here>" https://jenkins/script
# or to get output as a plain text result (no HTML)
curl -d "script=<your_script_here>" https://jenkins/scriptText

bash를 통해 Groovy 파일을 제출하는 Curl

curl --data-urlencode "script=$(< ./somescript.groovy)" https://jenkins/scriptText

bash를 통해 사용자 이름과 API 토큰을 제공하는 Groovy 파일을 제출하는 Curl

curl --user 'username:api-token' --data-urlencode \
  "script=$(< ./somescript.groovy)" https://jenkins/scriptText

사용자 이름과 API 토큰을 제공하는 그루비 파일을 제출하는 Python

with open('somescript.groovy', 'r') as fd:
    data = fd.read()
r = requests.post('https://jenkins/scriptText', auth=('username', 'api-token'), data={'script': data})

제출할 스크립트 콘솔의 단축키

윈도우/리눅스: Ctrl + Enter
맥: Command + Enter

비디오 튜토리얼 및 추가 학습 자료

Jenkins Script Console 녹화 영상
- Jenkins World 2017: Jenkins Script Console 마스터하기 - 44분 - 샘플 사용 및 보안 토론
- LA Jenkins Area Meetup 2016 - Jenkins 내부 해킹 - Jenkins 스크립트 콘솔 - 39분 - 샘플 사용
Script Console에서 스크립트 작성 능력 확장
- Groovy 배우기 / Groovy Pipeline 및 공유 Pipeline Library / Groovy 플러그인 / Job DSL 플러그인
- 코드 완성 기능을 갖춘 Jenkins용 Groovy Script 작성
  - IDE 내에서 Maven 프로젝트 생성
  - org.jenkins-ci.main:jenkins-core(및 현재 예상되는 기타 플러그인)에 의존
  - Jenkins API 개체 및 메서드의 코드 완성 기능을 사용하여 Groovy Script 작성 가능

Jenkins Pipeline

Fri, 03 Nov 2023 00:00:00 +0900

개요

개요
정의
역할
목적
Pipeline 생성 방법
Jenkins File 작성 방법
Scripted Pipeline
Pipeline 생성 방법

정의

젠킨스의 플러그인

역할

연속적인 이벤트
Job의 그룹 실행

목적

단순한 Job들이 많아지는 경우 Job을 관리하기 어려움
Pipeline으로 작성 시 하나의 Job으로 묶으면 관리하기 편함
진행 상황, 직관적인 파악 가능

Pipeline 생성 방법

WEB UI를 통해 Job 구성에서 Script 코드 작성
SCM을 이용해 Jenkinsfile에 DSL(Domain-Specific Language)로 작성된 스크립트 코드 작성 필요
Blueocean 플러그인으로 UI를 통해 스크립트 코드 작성

Jenkins File 작성 방법

Groovy Script로 작성
Declarative Pipeline
- Scripted Pipeline보다 쉽게 작성 가능
- Groovy 문법 기반
- 최상단에 pipeline이라고 되어 있으면 declarative 문법으로 작성된 것
Scripted Pipeline
- Declarative보다 효과적이고 많은 기능 포함 작성 가능
- Groovy 문법 기반
- 최상단에 node 지시어가 있으면 scripted 문법으로 작성된 것
Declarative Pipeline와 Scripted Pipeline 동시 작성 불가

Scripted Pipeline

Directive(지시어)
- node: Scripted Pipeline을 실행하는 Jenkins 에이전트 / 최상단에 선언
- dir: 명령어를 수행할 directory(폴더) 정의
- stage: 파이프라인 각 단계, 어떤 작업을 할지 선언(작업 내용 작성)
- git: git 원격 저장소에서 프로젝트 clone
- sh: unix 환경에서 실행할 명령어 실행(윈도우: bat)
- def: groovy 변수, 함수 선언(javascript에서 var)
작성 방법

node('worker'){
  stage('source'){
    // stage에서 수행할 코드 작성
  }
}

// 예시 1
pipeline {
  agent any

  stages() {
    stage('git clone'){
      steps() {
        git 'https://github.com/git아이디/git레포지토리.git'
      }
    }

    stage('Test') {
      steps{
        echo 'Testing..'
      }
    }

    stage('execute sh') {
      steps {
        sh 'chmod 774 ./파일이름"
        sh './파일이름"
      }
    }
  }
}

// 예시 2
node {
    stage('git clone') {
        git 'https://github.com/git아이디/git레포지토리.git'
    }
    stage('Test') {
        echo 'Testing....'
    }
    stage('execute sh') {
		sh "chmod 774 ./파일이름"
        sh "./파일이"
    }
}

Flow Control

// if문 사용 가능

node {
    stage('Example') {
        if (env.BRANCH_NAME == '메인브랜치') {
            echo '메인 브랜치'
        } else {
            echo '다른 브랜치'
        }
    }
}

// 예외 처리 가능

node {
    stage('Example') {
        try {
            sh 'exit 1'
        }
        catch (exc) {
            echo 'error'
            throw
        }
    }
}

Pipeline 생성 방법

Web UI에서 Jenkinsfile 작성
- Jenkins 대시보드에서 새로운 Item 선택 > Pipeline 선택
- 설명 작성 후 Pipeline 탭 선택 > Definition에서 Pipeline script 선택 > 스크립트 작성 후 저장
- Build Now 클릭
SCM을 이용해 Jenkinsfile 작성
- 테스트할 Repository에 Jenkinsfile 생성 후 샘플 코드 작성
- Jenkins 대시코드에서 새로운 Item 선택 > 아이템 이름 작성 후 Pipeline 선택
- Definition에서 Pipeline script from SCM 선택 > SCM 항목에서 Git 선택 > 원격 저장소 작성 > Credentials에서 계정 선택 > Branches to build에서 메인 branch 작성 > Script Path에서 Jenkinsfile 위치 작성(최상단일 경우 Default)
- Build Triggers 항목에서 Github hook trigger for GITScm Polling 체크(메인 브랜치에 Push 했을 때 Build 됨)
- Build Now 클릭(최초 1회 빌드됨)
- 아무 파일 생성, 수정 후 원격 저장소의 메인 branch에 push, build 확인

Groovy Script

Thu, 02 Nov 2023 00:00:00 +0900

개요

개요
Groovy란
장점
단점
문법

Groovy란

Java에 Python, Ruby 등의 특징을 더한 동적 객체 지향 프로그래밍 언어
JVM에서 실행되는 스크립트 언어
Java 호환 가능(Java Class 사용 가능)
단순화된 문법을 지원

장점

코드를 읽고 유지보수하기 편함
더 많은 절차적인 코드를 작성 가능
프로그램 작성과 흡사
기존 파이프 라인 문법이라 친숙하고 이전 버전과 호환 가능
필요한 경우 커스텀한 작업 생성이 가능하기 때문에 유연성 좋음
보다 복잡한 워크 플로우 및 파이프 라인 모델링 가능

단점

일반적으로 더 많은 프로그래밍이 필요
Groovy 언어 및 환경으로 제한된 구문 검사
전통적인 Jenkins 모델과는 맞지 않음
같은 작업이라면 Declarative 문법보다 잠재적으로 더 복잡

문법

문자열

문자열 표기 방법: ‘‘(작은 따옴표) OR ““(큰 따옴표)

’‘(작은 따옴표): 단순한 문자열 출력

”“(큰 따옴표): 문자열 출력, 문자열 내부에 $변수를 이용해 동적인 내용을 표시하는데에 사용 가능

’’’ ‘’’ (작은 따옴표 3개) OR “”” “”“(큰 따옴표 3개로 열고닫기): 여러 행 출력

메소드 호출

괄호 생략 가능

println ('hello')
println 'hello'

형 생략

def 사용 시 모든 타입 변수 생성 가능

String message = 'hi'
def message = 'hi'

클로저(Closure)

클로저: Java의 Lambda(람다)와 매우 유사한 성격의 기능, 어떤 메소드의 인수로 전달할 처리문

실행 방법: <클로저이름>.call() OR <클로저이름>() 으로 실행 가능

def clos1 = {
    println 'hi'
}
​
// 실행
clos1.call()
clos1()

3D Contribution 적용법

Sat, 28 Oct 2023 00:00:00 +0900

개요

개요
사용 계기
목적
사용 방법
느낀점

사용 계기

Github 프로필을 작성하는 도중 여러 Github 사용자들의 README.md 파일을 구경하게 되었다.

이때 시각적으로 Contribution을 확인할 수 있는 프로필을 보고 나도 하고 싶다는 생각에 3D Contribution을 찾아보게 되었다.

목적

Github 프로필에 시각적으로 Contribution을 보여주기 위함

사용 방법

1. Repository 생성

Repository name = Owner

(참고) 이미 존재하는 Repository이기 때문에 경고 표시가 뜸

2. Token 생성

Settings > Developer Settings

Personal access tokens > Tokens(classic)

Generate new token > Generate new token(classic)

3. Settings 설정

본인 Repository 내 Settings

Security > Secrets and variables > Action

New repository secret 클릭

Name: Token

Secret: Token 복사/붙여넣기

Add secret 클릭

4. Action 설정

Action 클릭

New workflow 클릭

set up a workflow yourself 클릭

파일 이름: main.yml > profile-3d.yml 변경

아래 내용 복사/붙여넣기

깃허브이름, 깃허브이메일 이라고 작성된 부분은 각자 Github name, email로 수정

name: GitHub-Profile-3D-Contrib

on:
  schedule: # 03:00 JST == 18:00 UTC
    - cron: "0 18 * * *"
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest
    name: generate-github-profile-3d-contrib
    steps:
      - uses: actions/checkout@v2
      - uses: yoshi389111/github-profile-3d-contrib@0.6.0
        env:
          GITHUB_TOKEN: $
          USERNAME: $
      - name: Commit & Push
        run: |
          git config user.name 깃허브이름
          git config user.email 깃허브이메일
          git add -A .
          git commit -m "generated"
          git push

Run workflow > Run workflow

5. README 파일에 추가

아래 코드 복사/붙여넣기(적용한 테마: south-season-animate)

![](./profile-3d-contrib/profile-south-season-animate.svg)

원하는 테마 적용

샘플 https://github.com/yoshi389111/github-profile-3d-contrib.git

profile-3d-contrib/profile-green-animate.svg
profile-3d-contrib/profile-green.svg
profile-3d-contrib/profile-season-animate.svg
profile-3d-contrib/profile-season.svg
profile-3d-contrib/profile-south-season-animate.svg
profile-3d-contrib/profile-south-season.svg
profile-3d-contrib/profile-night-view.svg
profile-3d-contrib/profile-night-green.svg
profile-3d-contrib/profile-night-rainbow.svg
profile-3d-contrib/profile-gitblock.svg

느낀점

Github Action 기능을 시도해 보지 않았을 때는 어려울 거라고 생각했다. 이 기회에 처음 시도해 보는 기능이었지만 사용하면 편리한 기능임을 깨달았다. 앞으로는 Workflow를 자동화할 때 자주 사용하려 한다.

.env 파일 사용법

Mon, 23 Oct 2023 00:00:00 +0900

개요

개요
사용 계기
목적
사용 방법
느낀점

사용 계기

프로젝트를 진행하면서 AWS S3, RDS를 활용하기 위한 AWS 계정의 Access Key, SMTP 기능을 구현하기 위한 포트 번호, 비밀번호를 안전하게 저장하는 것이 중요했다. 하지만 프로젝트 초기에 보안 문제를 해결하지 않고 Public으로 설정한 Github Repository에 commit 및 push 했다. 이때 민감한 정보가 노출되어 보안 문제가 발생했다.

이 문제를 해결하기 위해 .env 파일에 대해 조사하였다.

목적

SECRET_KEY, AWS_ACCESS_KEY, EMAIL_HOST, 포트 번호 등 외부에 알려지면 안 되는 값들을 보안, 유지보수를 용이하게 하기 위함

사용 방법

1. decouple 설치

// Terminal 창

pip install python-decouple

2. 프로젝트 최상위 루트 경로에 .env 파일 생성

Django Framework를 사용한 프로젝트는 manage.py와 같은 경로에 위치

3. .env 파일에 보안이 필요한 정보 작성

// 예시 

SECRET_KEY = 

DATABASE_NAME = 
DATABASE_USER = 
DATABASE_PASSWORD = 
DATABASE_HOST = 
DATABASE_PORT = 

EMAIL_HOST = 
EMAIL_PORT = 
EMAIL_USER = 
EMAIL_PASSWORD = 

AWS_REGION = 
AWS_STORAGE_BUCKET_NAME = 
AWS_ACCESS_KEY_ID = 
AWS_SECRET_ACCESS_KEY = 

주의사항

Key=Value (O)

Key=”Value” (X)

4. .env 파일 정보 사용

Django Framework를 사용한 프로젝트는 settings.py에 설정값 작성

// import 설정
from decouple import config

// 코드 내 작성 예시
SECRET_KEY = config('SECRET_KEY')

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': config('DATABASE_NAME'),
        'USER': config('DATABASE_USER'),
        'PASSWORD': config('DATABASE_PASSWORD'),
        'HOST': config('DATABASE_HOST'),
        'PORT': config('DATABASE_PORT'),
        'OPTIONS': {
            'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
        }
    }
}

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = config('EMAIL_HOST')
EMAIL_USE_TLS = True
EMAIL_PORT = config('EMAIL_PORT')
DEFAULT_FROM_EMAIL = config('EMAIL_USER')
EMAIL_HOST_USER = config('EMAIL_USER')
EMAIL_HOST_PASSWORD = config('EMAIL_PASSWORD')

AWS_REGION = config('AWS_REGION')
AWS_STORAGE_BUCKET_NAME = config('AWS_STORAGE_BUCKET_NAME')
AWS_ACCESS_KEY_ID = config('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = config('AWS_SECRET_ACCESS_KEY')

AWS_S3_CUSTOM_DOMAIN = f"{AWS_STORAGE_BUCKET_NAME}.s3.{AWS_REGION}.amazonaws.com"

5. .gitignore 파일에 .env 파일 추가

// .gitignore 파일

.env

느낀점

초기에 보안 문제를 간과하면 나중에 해킹이나 개인정보 유출 문제로 이어질 수 있음을 깨달았다. 앞으로는 보안 검토를 강화하고, 민감한 데이터를 안전하게 보호하려 한다.

Github Pull Request 사용 방법

Fri, 20 Oct 2023 00:00:00 +0900

개요

개요
용어 설명
목적
설정
사용 방법

용어 설명

Pull Request: Repository에 대한 제안된 변경 사항

Repository: 프로젝트 파일, 각 파일의 수정 기록(Issue), 프로젝트의 작업을 논의하고 관리할 수 있는 공간

branch: Repository에 적용하는 변경 사항과 별도로 기능 개발, 버그 수정을 안전하게 작업할 수 있는 작업 영역

push: branch에서 만든 commit을 repository에 적용

commit: 변경 사항 기록

merge: 기본 branch에 변경 사항을 병합

목적

Github Repository의 개인 branch에 push한 변경 사항을 다른 사람에게 알림
공동 작업자와 변경 사항을 논의 및 검토
변경 사항을 기본 branch에 merge

설정

branch 보호 설정

1. [Settings] > [Branches] > [Add branch protection rule]

2. Branch name pattern 설정, Protect matching branches 내 Require a pull request before merging 체크박스 선택

3. 승인 인원 설정

4. create 버튼 클릭

사용 방법

1. Git Push

2. Branches 확인

3. Compare & pull request 버튼 클릭

4. merge할 브랜치 확인

5. 필요 내용 입력 후 Create pull request 클릭

필요 내용: 제목, 설명, Reviewers, Assignees, Labels, Projects, Milestone

6. Merge pull request 클릭

6-1. Merge pull request가 비활성화일 때

해결 방법

안전네컷

Tue, 17 Oct 2023 00:00:00 +0900

VOV 프로젝트 ‘실시간’ 기능을 활용한 사진 촬영 프로젝트(포토부스)

개발 기간: 2023. 10. ~ 2023. 10.

개발 인원: 2

개발 언어: Python

Dataset: Roboflow

Model: Yolov5m

Framework: Django

IDE: Visual Studio Code

Library: OpenCV, Mediapipe, Numpy, PIL

ETC: SMTP, JQuery

시연 영상

Github Link

👀 담당 역할

팀장

데이터셋 구축 100% Roboflow 링크

모델 구축(하이퍼 파라미터 조정 및 모델 추출) 100% COLAB 링크

촬영 효과 100%

✔️ 프로젝트 목적

기획 의도

AI 기반의 생채 정보 보안을 위한 지문 비식별화

개인정보 데이터 관리의 중요성 인식 확산

프로젝트 내용

지문 영역 인지 및 지문 식별 정보 추출

추출된 지문 비식별화

후처리된 파일 이메일 전송

✔️ 프로젝트 특장점

Mediapipe 라이브러리 및 YOLOv5 모델로 높은 정확도와 빠른 속도로 지문 추출

✔️ 주요 기술

Mediapipe 라이브러리를 사용하여 손 끝 위치를 감지
Custom YOLOv5m 모델을 사용하여 지문 식별(mAP50 0.903)

✔️ 기타 링크

Custom Dataset - Roboflow

VOV

Fri, 13 Oct 2023 00:00:00 +0900

개인정보 비식별화 지원 서비스 개발 프로젝트 VOV

개발 기간: 2023. 08. ~ 2023. 10.

개발 인원: 4

개발 언어: Python

Dataset: Roboflow

Model: Yolov5m

Framework: Django

DB: AWS RDS(mariaDB)

IDE: Visual Studio Code

Library: OpenCV, Mediapipe, Numpy

ETC: UML, SonarQube, S3, SMTP, JQuery

시연 영상

Github Link

👀 담당 역할

팀장

문서 작업 25% 링크

데이터셋 구축 100% Roboflow 링크

모델 구축(하이퍼 파라미터 조정 및 모델 추출) 100% COLAB 링크

실시간 촬영 시 모델 이용하여 지문 감지 100% Github 링크

실시간 촬영 시 감지된 지문 후처리(블러) 100% Github 링크

✔️ 프로젝트 목적

기획 의도

AI 기반의 생채 정보 보안을 위한 지문 비식별화

개인정보 데이터 관리의 중요성 인식 확산

프로젝트 내용

지문 영역 인지 및 지문 식별 정보 추출

추출된 지문 비식별화

후처리된 파일 저장 및 전송

✔️ 프로젝트 특장점

Mediapipe 라이브러리 및 YOLOv5m 모델로 높은 정확도와 빠른 속도로 지문 추출
기존 지문 인식 시스템의 부족한 보호 기능 보완
보안을 위해 후처리된 이미지만 데이터베이스에 저장
안정적인 AWS 인프라 및 다양한 산업 분야에서 활용 가능
사용자 친화적 환경으로 업로드 및 결과 처리 용이

✔️ 주요 기술

Mediapipe 라이브러리를 사용하여 손 끝 위치를 감지
Custom YOLOv5m 모델을 사용하여 지문 식별(mAP50 0.903)
AWS 인프라를 활용한 무중단 배포와 S3, RDS를 이용한 데이터 저장 및 클라우드 서비스 제공

✔️ 기술 스택

서비스 구성도

메뉴 구성도

Usecase

알고리즘 명세서

✔️ 테이블 설계

✔️ 기타 링크

활용 예시

Chroma Lens

Fri, 30 Jun 2023 00:00:00 +0900

색약자를 위한 이미지 색채 감지 프로젝트

개발 기간: 2023. 06. ~ 2023. 06

개발 인원: 2

개발 언어: Python

Dataset: Roboflow

Model: Yolov8m

Framework: Django

IDE: Google COLAB, Pycharm

Library: OpenCV, PIL

시연 영상

Github Link

👀 담당 역할

데이터셋 구축 50% Roboflow 링크

모델 구축(하이퍼 파라미터 조정 및 모델 추출) 50% Colab 링크

Django 환경 Setting 100%

파일 업로드 시 Bounding Box 50% Github 링크

실시간 촬영 시 Bounding Box 100% Github 링크

✔️ 개발 배경

색약자들이 일상생활 속에서 불분명한 색채 인식으로 인해 겪을 수 있는 불편함 해소

✔️ 개발 필요성

색상을 추출하는 인공지능 서비스는 많지만 색 공간을 명시하고, 라벨링하는 서비스는 미흡
자율주행기술이 대두되면서 색을 감지하고 경계선을 인식하는 인공지능 개발 필요성 등장

✔️ 프로그램 특장점

간편한 이미지 업로드
즉각적인 이미지 분석
색상 분류 및 색 공간 형태 명시
실시간 처리 가능

✔️ 개발 과정

✔️ 사용 과정

✔️ 모델 구현

데이터셋 구축

Roboflow 링크

6개 클래스(brown, green, orange, purple, red, yellow)에 해당하는 색 이미지를 수집

Poligon Tool로 라벨링 작업

신뢰도, 정확도를 낮추거나 과적합을 일으키는 데이터셋 필터링

모델 설계

Colab 링크

Confusion Matrix(혼동행렬)

✔️ 기대효과 및 활용분야

색 인식에 보다 원활한 시각적 의사소통을 보편적으로 가능하게 함
기계장치, 자율주행 차량 등이 중앙선, 신호등, 경고등 등을 인식

Varda

Fri, 19 May 2023 00:00:00 +0900

스킨케어 화장품 구매 사이트

개발 기간: 2023. 04 ~ 2023. 05

개발 인원: 5

개발 언어: Java

Framework: Spring boot

DB: MyBatis

IDE: Eclipse

Github Link

👀 담당 역할

부팀장

와이어프레임 100%

데이터베이스 100%

장바구니 프론트(.jsp) 100% Github 링크

장바구니 백엔드(.java) 100% Github 링크

✔️ 개발 배경

기초케어 화장품만 판매하는 사이트는 존재하지 않음
타사 홈페이지에서는 기초케어 화장품에 관한 카테고리가 단순

✔️ 프로젝트 목적

스킨케어 위주의 제품 판매
카테고리 세분화로 목적에 따른 상품 구매 가능

✔️ 프로젝트 설명

기술 스택

메뉴 구성

Product

Skin Type

Men/Women

테이블 구성

✔️ 개발 절차

SWIF

Thu, 15 Dec 2022 00:00:00 +0900

스터디매칭 어플리케이션

개발 기간: 2022. 03. ~ 2022. 10.

개발 인원: 4

개발 언어: Java

DB: Firebase

IDE: Android Studio

시연 영상

Github Link

👀 담당 역할

팀원

UI/UX 20%

매칭페이지 기능 100% Github 링크

메인페이지 달력 및 투두 100% Github 링크

✔️ 개발 배경

코로나19 확산 이후 온라인 독서실 및 스터디앱 사용량 증가
SWOT 분석

✔️ 개발 필요성

오프라인 독서실 사용 대비 비용 절감

✔️ 핵심 기능

타이머로 간단하게 총 공부 시간 기록
채팅을 통해 타 사용자와 서로 스터디 결과물 확인
게시판을 통한 사용자와 정보 공유

✔️ 사용 프로그램

✔️ UI/UX

클릭 시 Figma 이동