Go에서 Windows 서비스 작성

목차

• 소개
• Windows "서비스"란 정확히 무엇인가요?
• 왜 Golang인가요?
• Go로 Windows 서비스 작성
• 서비스 설치 및 시작
• 결론
• 완전한 코드

소개

안녕하세요 개발자 여러분, 오랜만에 윈도우 같은 글을 작성해봤습니다. 그래서 오늘은 Go에서 Windows 서비스 애플리케이션을 작성하는 방법을 안내해 드리고자 합니다. 네, 맞습니다. 바둑 언어입니다. 이 튜토리얼 블로그에서는 Windows 서비스 애플리케이션에 대한 몇 가지 기본 사항을 다룰 것이며, 후반부에서는 일부 정보를 파일에 기록하는 Windows 서비스용 코드를 작성하는 간단한 코드를 안내하겠습니다. 더 이상 고민하지 말고 시작해 보세요...!

Windows "서비스"란 정확히 무엇입니까?

Windows 서비스 애플리케이션(일명 Windows 서비스)은 백그라운드에서 실행되는 작은 애플리케이션입니다. 일반 Windows 응용 프로그램과 달리 GUI나 어떤 형태의 사용자 인터페이스도 없습니다. 이러한 서비스 응용 프로그램은 컴퓨터가 부팅될 때 실행되기 시작합니다. 실행 중인 사용자 계정에 관계없이 실행됩니다. 수명 주기(시작, 중지, 일시 중지, 계속 등)는 SCM(서비스 제어 관리자)이라는 프로그램에 의해 제어됩니다.

따라서 우리는 SCM이 Windows 서비스와 상호 작용하고 수명 주기를 관리하는 방식으로 Windows 서비스를 작성해야 한다는 것을 이해할 수 있습니다.

왜 골랭인가?

Windows 서비스 작성 시 Go를 고려할 수 있는 몇 가지 요소가 있습니다.

동시성

Go의 동시성 모델을 사용하면 더 빠르고 리소스 효율적인 처리가 가능합니다. Go의 고루틴을 사용하면 차단이나 교착 상태 없이 멀티 태스킹을 수행할 수 있는 애플리케이션을 작성할 수 있습니다.

간단

전통적으로 Windows 서비스는 C++ 또는 C(때로는 C#)를 사용하여 작성되어 코드가 복잡할 뿐만 아니라 DX(개발자 경험)도 좋지 않습니다. Go의 Windows 서비스 구현은 간단하며 모든 코드 줄이 의미가 있습니다.

정적 바이너리

"파이썬처럼 더 간단한 언어를 사용해 보는 건 어떨까요?"라고 물을 수도 있습니다. 그 이유는 Python의 해석 특성 때문입니다. Go는 Windows 서비스가 효율적으로 작동하는 데 필수적인 정적으로 연결된 단일 파일 바이너리로 컴파일합니다. Go 바이너리에는 런타임/인터프리터가 필요하지 않습니다. Go 코드는 크로스 컴파일도 가능합니다.

낮은 수준의 액세스

Go는 가비지 수집 언어이기는 하지만 하위 수준 요소와 상호 작용할 수 있는 견고한 지원을 제공합니다. go에서 win32 API와 일반 시스템 호출을 쉽게 호출할 수 있습니다.

알겠습니다. 정보는 충분합니다. 코딩해보자...

Go로 Windows 서비스 작성

이 코드 연습에서는 사용자가 Go 구문에 대한 기본 지식이 있다고 가정합니다. 그렇지 않다면 A Tour of Go를 통해 배울 수 있습니다.

• 먼저 프로젝트 이름을 정하겠습니다. 내 이름을 cosmic/my_service로 지정하겠습니다. go.mod 파일을 생성하고,

PS C:\> go mod init cosmic/my_service

• 이제 golang.org/x/sys 패키지를 설치해야 합니다. 이 패키지는 Windows OS 관련 애플리케이션에 대한 Go 언어 지원을 제공합니다.

PS C:\> go get golang.org/x/sys

참고: 이 패키지에는 Mac OS 및 Linux와 같은 UNIX 기반 OS에 대한 OS 수준 Go 언어 지원도 포함되어 있습니다.

• main.go 파일을 생성합니다. main.go 파일에는 Go 애플리케이션/서비스의 진입점 역할을 하는 주요 기능이 포함되어 있습니다.

• 서비스 인스턴스를 생성하려면 golang.org/x/sys/windows/svc에서 핸들러 인터페이스를 구현하는 Service Context라는 항목을 작성해야 합니다.

인터페이스 정의는 다음과 같습니다

type Handler interface {
    Execute(args []string, r <-chan ChangeRequest, s chan<- Status) (svcSpecificEC bool, exitCode uint32)
}

Execute 함수는 서비스 시작 시 패키지 코드에 의해 호출되며, Execute가 완료되면 서비스가 종료됩니다.

수신 전용 채널 r에서 서비스 변경 요청을 읽고 그에 따라 조치합니다. 또한 전송 전용 채널에 신호를 보내 서비스를 최신 상태로 유지해야 합니다. args 매개변수에 선택적 인수를 전달할 수 있습니다.

종료 시 성공적으로 실행되면 종료 코드가 0으로 반환될 수 있습니다. 이를 위해 svcSpecificEC를 사용할 수도 있습니다.

• 이제 서비스 컨텍스트 역할을 할 myService라는 유형을 만듭니다.

type myService struct{}

• myService 유형을 생성한 후 위에서 언급한 Execute를 메소드로 추가하여 Handler 인터페이스를 구현합니다.

func (m *myService) Execute(args []string, r <-chan svc.ChangeRequest, status chan<- svc.Status) (bool, uint32) {
    // to be filled
}

• 이제 핸들러 인터페이스를 성공적으로 구현했으므로 실제 로직 작성을 시작할 수 있습니다.

저희 서비스가 SCM에서 받을 수 있는 신호로 상수를 만듭니다.

const cmdsAccepted = svc.AcceptStop | svc.AcceptShutdown | svc.AcceptPauseAndContinue

Our main goal is the log some data every 30 seconds. So we need to define a thread safe timer for that.

tick := time.Tick(30 * time.Second)

So, we have done all the initialization stuffs. It's time to send START signal to the SCM. we're going to do exactly that,

status <- svc.Status{State: svc.StartPending}
status <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}

Now we're going to write a loop which acts as a mainloop for our application. Handling events in loop makes our application never ending and we can break the loop only when the SCM sends STOP or SHUTDOWN signal.

loop:
    for {
        select {
        case <-tick:
            log.Print("Tick Handled...!")
        case c := <-r:
            switch c.Cmd {
            case svc.Interrogate:
                status <- c.CurrentStatus
            case svc.Stop, svc.Shutdown:
                log.Print("Shutting service...!")
                break loop
            case svc.Pause:
                status <- svc.Status{State: svc.Paused, Accepts: cmdsAccepted}
            case svc.Continue:
                status <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
            default:
                log.Printf("Unexpected service control request #%d", c)
            }
        }
    }

Here we used a select statement to receive signals from channels. In first case, we handle the Timer's tick signal. This case receives signal every 30 seconds, as we declared before. We log a string "Tick Handled...!" in this case.

Secondly, we handle the signals from SCM via the receive-only r channel. So, we assign the value of the signal from r to a variable c and using a switch statement, we can handle all the lifecycle event/signals of our service. We can see about each lifecycle below,

1. svc.Interrogate - Signal requested by SCM on a timely fashion to check the current status of the service.
2. svc.Stop and svc.Shutdown - Signal sent by SCM when our service needs to be stopped or Shut Down.
3. svc.Pause - Signal sent by SCM to pause the service execution without shutting it down.
4. svc.Continue - Signal sent by SCM to resume the paused execution state of the service.

So, when on receiving either svc.Stop or svc.Shutdown signal, we break the loop. It is to be noted that we need to send STOP signal to the SCM to let the SCM know that our service is stopping.

status <- svc.Status{State: svc.StopPending}
return false, 1

• Now we write a function called runService where we enable our service to run either in Debug mode or in Service Control Mode.

Note: It's super hard to debug Windows Service Applications when running on Service Control Mode. That's why we are writing an additional Debug mode.

func runService(name string, isDebug bool) {
    if isDebug {
        err := debug.Run(name, &myService{})
        if err != nil {
            log.Fatalln("Error running service in debug mode.")
        }
    } else {
        err := svc.Run(name, &myService{})
        if err != nil {
            log.Fatalln("Error running service in debug mode.")
        }
    }
}

• Finally we can call the runService function in our main function.

func main() {

    f, err := os.OpenFile("debug.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalln(fmt.Errorf("error opening file: %v", err))
    }
    defer f.Close()

    log.SetOutput(f)
    runService("myservice", false) //change to true to run in debug mode
}

Note: We are logging the logs to a log file. In advanced scenarios, we log our logs to Windows Event Logger. (phew, that sounds like a tongue twister ?)

• Now run go build to create a binary '.exe'. Optionally, we can optimize and reduce the binary file size by using the following command,

PS C:\> go build -ldflags "-s -w"

Installing and Starting the Service

For installing, deleting, starting and stopping our service, we use an inbuilt tool called sc.exe

To install our service, run the following command in powershell as Administrator,

PS C:\> sc.exe create MyService <path to your service_app.exe>

To start our service, run the following command,

PS C:\> sc.exe start MyService

To delete our service, run the following command,

PS C:\> sc.exe delete MyService

You can explore more commands, just type sc.exe without any arguments to see the available commands.

Conclusion

As we can see, implementing Windows Services in go is straightforward and requires minimal implementation. You can write your own windows services which acts as a web server and more. Thanks for reading and don't forget to drop a ❤️.

Complete Code

Here is the complete code for your reference.

// file: main.go

package main

import (
    "fmt"
    "golang.org/x/sys/windows/svc"
    "golang.org/x/sys/windows/svc/debug"
    "log"
    "os"
    "time"
)

type myService struct{}

func (m *myService) Execute(args []string, r <-chan svc.ChangeRequest, status chan<- svc.Status) (bool, uint32) {

    const cmdsAccepted = svc.AcceptStop | svc.AcceptShutdown | svc.AcceptPauseAndContinue
    tick := time.Tick(5 * time.Second)

    status <- svc.Status{State: svc.StartPending}

    status <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}

loop:
    for {
        select {
        case <-tick:
            log.Print("Tick Handled...!")
        case c := <-r:
            switch c.Cmd {
            case svc.Interrogate:
                status <- c.CurrentStatus
            case svc.Stop, svc.Shutdown:
                log.Print("Shutting service...!")
                break loop
            case svc.Pause:
                status <- svc.Status{State: svc.Paused, Accepts: cmdsAccepted}
            case svc.Continue:
                status <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
            default:
                log.Printf("Unexpected service control request #%d", c)
            }
        }
    }

    status <- svc.Status{State: svc.StopPending}
    return false, 1
}

func runService(name string, isDebug bool) {
    if isDebug {
        err := debug.Run(name, &myService{})
        if err != nil {
            log.Fatalln("Error running service in debug mode.")
        }
    } else {
        err := svc.Run(name, &myService{})
        if err != nil {
            log.Fatalln("Error running service in debug mode.")
        }
    }
}

func main() {

    f, err := os.OpenFile("E:/awesomeProject/debug.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalln(fmt.Errorf("error opening file: %v", err))
    }
    defer f.Close()

    log.SetOutput(f)
    runService("myservice", false)
}

위 내용은 Go에서 Windows 서비스 작성의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!