저도 처음에는 단순히 메일만 들어오면 된다고 생각했는데, 막상 설정해보니 MX 레코드, A 레코드, 시놀로지 MailPlus, 루트 도메인 접속 문제까지 함께 이해해야 제대로 동작했습니다. 특히 가비아 DNS에서 MX 값에 무엇을 넣어야 하는지, 그리고 why howinfo.kr 자체가 안 열리는지에서 가장 많이 헷갈렸습니다.

이번 글은 그런 시행착오를 줄이기 위해 정리한 실전 기록입니다.
설명에 사용하는 IP는 실제 값이 아니라 예시용 가상 IP입니다.

이 글에서 정리하는 내용

이 글에서는 아래 내용을 한 번에 정리합니다.

• admin@howinfo.kr 메일을 시놀로지에서 받는 전체 구조
• 가비아 DNS에서 A, MX 레코드를 어떻게 넣어야 하는지
• howinfo.kr 접속이 안 될 때 무엇을 먼저 봐야 하는지
• 시놀로지 MailPlus에서 어떤 방식으로 계정을 연결하면 편한지
• 설정 중 자주 만나는 오류와 해결 포인트

왜 도메인 메일이 필요한가

개인 메일 주소 대신 사이트 도메인 메일을 쓰면 운영 체계가 훨씬 정돈되어 보입니다. 예를 들어 admin@howinfo.kr 라는 주소는 사이트 관리자용 공식 창구처럼 보이기 때문에 방문자 입장에서도 신뢰도가 높습니다.

또한 도메인 메일은 문의 메일, 협업 요청, 운영 경고, 서비스 알림을 한곳으로 모으기 좋습니다. 이미 시놀로지 NAS를 사용하고 있다면 별도 외부 메일 서비스를 추가하지 않고도 직접 메일 수신 환경을 만들 수 있다는 점도 장점입니다.

먼저 이해해야 하는 전체 구조

도메인 메일은 아래 순서로 동작합니다.

1. 누군가 admin@howinfo.kr 로 메일을 보냅니다.
2. 발신 서버는 howinfo.kr 의 MX 레코드를 조회합니다.
3. MX 레코드는 메일을 받을 서버 이름을 알려줍니다.
4. 그 서버 이름은 다시 A 레코드를 통해 IP와 연결됩니다.
5. 최종적으로 시놀로지 MailPlus Server가 메일을 수신합니다.

여기서 핵심은 두 가지입니다.

첫째, MX는 메일 서버의 이름을 가리킵니다.
둘째, A 레코드는 그 이름을 실제 IP와 연결합니다.

즉 MX에는 IP를 넣는 것이 아니라 mail.howinfo.kr 같은 주소를 넣어야 합니다.

MX에 IP를 넣으면 안 되는 이유

처음 가장 많이 하는 실수가 바로 이 부분입니다.

아래처럼 설정하면 안 됩니다.

MX / @ / 203.0.113.25

이건 잘못된 방식입니다.
MX는 메일 서버 이름을 가리켜야 하기 때문입니다.

올바른 예시는 아래와 같습니다.

A  / mail / 203.0.113.25
MX / @    / mail.howinfo.kr

즉 먼저 mail.howinfo.kr 이라는 이름을 만들고, 그 이름을 A 레코드로 IP에 연결한 다음, MX는 그 이름을 바라보게 해야 합니다.

이 구조를 이해하면 메일 DNS 설정은 훨씬 쉬워집니다.

howinfo.kr 기준 DNS 예시

설명을 위한 가상 IP 203.0.113.25 를 기준으로 하면, 최소한 아래처럼 구성하면 됩니다.

웹 접속용

A / @   / 203.0.113.25
A / www / 203.0.113.25

메일 수신용

A  / mail / 203.0.113.25
MX / @    / mail.howinfo.kr

표로 정리하면 아래와 같습니다.

이 4줄이 가장 기본적인 핵심 설정입니다.

howinfo.kr 이 안 열릴 때 먼저 볼 것

실제로 설정 중 자주 겪는 문제가 있습니다.

• www.howinfo.kr 는 열리는데
• howinfo.kr 는 안 열리는 경우

이 경우는 대부분 아래 레코드가 빠져 있습니다.

A / @ / 203.0.113.25

많은 분들이 www 만 설정하고 루트 도메인 @ 를 빼먹습니다. 하지만 howinfo.kr 와 www.howinfo.kr 는 별도로 동작할 수 있기 때문에 둘 다 잡아줘야 합니다.

즉, howinfo.kr 자체 접속이 안 된다면 가장 먼저 A / @ 레코드를 확인하면 됩니다.

가비아 DNS에서 헷갈리는 부분

가비아 DNS 화면을 보면 호스트 와 값/위치 입력칸 때문에 처음에는 조금 헷갈릴 수 있습니다.

예를 들어 아래처럼 입력하면 됩니다.

A 레코드

• 타입: A
• 호스트: mail
• 값/위치: 203.0.113.25

이 뜻은 mail.howinfo.kr 이라는 주소를 해당 IP로 연결한다는 의미입니다.

MX 레코드

• 타입: MX
• 호스트: @
• 값/위치: mail.howinfo.kr
• 우선순위: 10

이 뜻은 howinfo.kr 로 들어오는 메일을 mail.howinfo.kr 가 받는다는 의미입니다.

여기서 가장 중요한 점은 MX 값에는 IP가 아니라 도메인 이름이 들어간다는 점입니다.

시놀로지 MailPlus에서는 어떻게 구성하면 좋은가

DNS가 끝나면 이제 시놀로지에서 메일을 받을 준비를 해야 합니다.

기본 순서는 아래와 같습니다.

1. DSM 패키지 센터에서 MailPlus Server 설치
2. 필요하면 MailPlus도 설치
3. 대표 메일 서버 이름 설정
4. SMTP, IMAP 활성화
5. 사용자 생성
6. admin@howinfo.kr 수신 연결

실무적으로는 내부 로그인용 계정과 외부 공개용 메일 주소를 분리하는 편이 편합니다.

예를 들어 아래처럼 운영할 수 있습니다.

• 내부 사용자: adminmail
• 외부 메일 주소: admin@howinfo.kr

이렇게 하면 외부에는 깔끔한 공식 메일 주소를 보여주면서도, 실제 시놀로지 내부에서는 관리하기 쉬운 사용자명으로 운영할 수 있습니다.

가장 단순한 추천 구성

howinfo.kr 하나만 기준으로 본다면 아래처럼 구성하면 충분합니다.

DNS

A  / @    / 203.0.113.25
A  / www  / 203.0.113.25
A  / mail / 203.0.113.25
MX / @    / mail.howinfo.kr

시놀로지

• MailPlus Server 설치
• 도메인 howinfo.kr 등록
• 사용자 adminmail 생성
• admin@howinfo.kr 수신 연결

운영 방식

• 외부에서는 admin@howinfo.kr 로 메일 발송
• 시놀로지 MailPlus 받은편지함에서 확인

이 구성이 가장 단순하면서도 관리하기 쉬운 형태입니다.

설정 중 자주 만나는 문제

MX를 넣었는데 메일이 안 들어오는 경우

이 경우는 보통 아래 둘 중 하나입니다.

• MX 값에 IP를 넣었음
• mail A 레코드가 없음

정상 예시는 아래입니다.

A  / mail / 203.0.113.25
MX / @    / mail.howinfo.kr

가비아에서 저장이 안 되는 경우

호스트를 입력해 주세요 같은 메시지가 뜬다면 새 레코드를 추가해놓고 빈 칸이 남아 있는 경우가 많습니다. 새 줄을 만들었으면 타입, 호스트, 값/위치를 모두 채운 뒤 저장해야 합니다.

howinfo.kr 자체가 접속되지 않는 경우

이 경우는 아래가 빠졌을 가능성이 큽니다.

A / @ / 203.0.113.25

DNS는 맞는데 메일이 안 들어오는 경우

이때는 DNS가 아니라 네트워크 문제일 수 있습니다. 아래를 같이 확인해야 합니다.

• 공유기 포트포워딩
• 외부 25번 포트 수신 가능 여부
• DSM 방화벽 허용 여부
• MailPlus Server 정상 실행 여부

실제 작업은 이 순서가 가장 편했습니다

제가 정리해보면 아래 순서가 가장 덜 헷갈립니다.

1단계. DNS 먼저 정리

A  / @    / 203.0.113.25
A  / www  / 203.0.113.25
A  / mail / 203.0.113.25
MX / @    / mail.howinfo.kr

2단계. 시놀로지 MailPlus 설치

• MailPlus Server
• MailPlus

3단계. 도메인 등록

• howinfo.kr

4단계. 사용자 생성

• adminmail

5단계. 수신 주소 연결

• admin@howinfo.kr

6단계. 외부 발송 테스트

• 다른 메일 계정에서 admin@howinfo.kr 로 발송
• 시놀로지 받은편지함에서 정상 수신 확인

이 순서대로 하면 중간에 꼬일 일이 많이 줄어듭니다.

운영 관점에서 느낀 점

howinfo.kr 같은 블로그나 정보 사이트를 운영할 때는 메일 시스템이 지나치게 복잡할 필요는 없습니다. 중요한 것은 문의를 놓치지 않고, 운영자가 쉽게 확인할 수 있으며, 외부에서 봤을 때 신뢰감을 주는 구조입니다.

admin@howinfo.kr 메일 주소는 그런 점에서 꽤 실용적입니다. 시놀로지 NAS를 이미 사용 중이라면 추가 비용 없이 직접 운영할 수 있다는 것도 장점입니다.

물론 발신까지 안정적으로 운영하려면 SPF, DKIM, DMARC, PTR 같은 설정도 추가로 고려해야 합니다. 하지만 첫 단계에서는 수신 구조부터 정확히 잡는 것이 우선입니다.

마무리 정리

이번 설정에서 가장 중요한 포인트는 두 가지였습니다.

하나는 MX에는 IP가 아니라 mail.howinfo.kr 같은 메일 서버 이름을 넣어야 한다는 점입니다.
다른 하나는 howinfo.kr 자체 접속을 위해 A / @ 레코드가 꼭 필요하다는 점입니다.

결국 핵심은 아래 4줄입니다.

A  / @    / 203.0.113.25
A  / www  / 203.0.113.25
A  / mail / 203.0.113.25
MX / @    / mail.howinfo.kr

이후 시놀로지 MailPlus에서 admin@howinfo.kr 수신 구조만 연결하면 기본적인 도메인 메일 환경은 완성됩니다.

처음에는 조금 복잡해 보여도 MX와 A 레코드의 역할만 제대로 구분하면 생각보다 어렵지 않게 정리할 수 있습니다.

체크리스트

아래 항목만 확인해도 대부분의 기본 오류는 줄일 수 있습니다.

• A / @ 레코드가 있는지
• A / mail 레코드가 있는지
• MX / @ / mail.howinfo.kr 로 설정했는지
• MailPlus Server가 실행 중인지
• 공유기 포트포워딩이 되어 있는지
• 외부에서 테스트 메일을 보내봤는지

FAQ

Q1. MX에는 왜 IP를 넣으면 안 되나요?

MX는 메일 서버의 이름을 지정하는 레코드이기 때문입니다. IP는 A 레코드가 담당합니다.

Q2. mail.howinfo.kr 는 꼭 필요한가요?

반드시 mail 이어야 하는 것은 아니지만, 메일 서버용 서브도메인을 따로 두는 방식이 일반적이고 관리하기도 쉽습니다.

Q3. howinfo.kr 는 안 열리고 www만 열리면 왜 그런가요?

대부분 A / @ 레코드가 빠져 있기 때문입니다.

Q4. admin@howinfo.kr 를 실제 로그인 계정으로 꼭 만들어야 하나요?

꼭 그렇지는 않습니다. 내부에서는 adminmail 같은 사용자로 운영하고, 외부 수신 주소만 admin@howinfo.kr 로 연결해도 됩니다.

Q5. 이 글의 IP를 그대로 써도 되나요?

아니요. 이 글의 IP는 예시용 가상 IP입니다. 실제 운영 시에는 본인의 공인 IP로 바꿔야 합니다.

게시물 시놀로지에서 admin@howinfo.kr 메일 받는 방법, 가비아 DNS와 MailPlus 설정 정리이 하우인포-IT·테크에 처음 등장했습니다.

저도 처음에는 이 부분이 제일 헷갈렸습니다. PC에서는 Docker 명령어가 보이고, 시놀로지 NAS에서는 Container Manager라는 이름으로 보이니 완전히 다른 제품처럼 느껴졌거든요. 그런데 실제로 써보면 구조는 생각보다 단순합니다. Docker는 컨테이너를 실행하는 기반 기술이고, DSM 7.3의 Container Manager는 NAS에서 그걸 좀 더 쉽게 다루게 해주는 관리 도구에 가깝습니다. Docker 컨테이너는 호스트의 커널을 공유하는 가벼운 격리 프로세스라 VM보다 부담이 적고, Docker Compose는 여러 서비스를 한 번에 정의하고 띄울 수 있게 해줍니다.

이번 글에서는

• Docker가 왜 필요한지
• 시놀로지 NAS에서 Container Manager로 무엇을 할 수 있는지
• 둘의 차이를 어떻게 이해하면 쉬운지
• 실제 예시는 어떤 식으로 시작하면 좋은지

이 순서로 정리해보겠습니다.

Docker를 한 문장으로 설명하면

Docker는 애플리케이션을 필요한 실행 환경과 함께 묶어서, 어느 서버에서든 비슷하게 실행할 수 있게 해주는 컨테이너 플랫폼입니다. Docker 공식 문서도 Docker를 “애플리케이션을 개발·배포·실행하기 위한 오픈 플랫폼”으로 설명하고 있고, 컨테이너는 필요한 파일을 포함한 격리된 프로세스로 설명합니다.

쉽게 말하면 이런 느낌입니다.

예전 방식은
“서버마다 설치 환경이 달라서 여기서는 되는데 저기서는 안 된다”는 문제가 자주 생겼습니다.

Docker 방식은
“앱 + 라이브러리 + 실행 환경”을 이미지로 묶어두고, 그 이미지를 어디서든 같은 방식으로 실행하는 구조입니다.

그래서 개발 PC에서 잘 돌던 앱을 NAS나 리눅스 서버로 옮길 때도 훨씬 예측 가능해집니다.

컨테이너와 가상머신은 무엇이 다를까

처음 입문할 때 가장 많이 비교하는 대상이 VM입니다.

가상머신은 운영체제 자체를 통째로 하나 더 올리는 느낌입니다.
반면 컨테이너는 호스트 OS의 커널을 공유하면서 필요한 프로세스만 격리해서 실행합니다. Docker 문서에서도 여러 컨테이너가 같은 커널을 공유한다고 설명합니다. 그래서 보통 컨테이너가 더 가볍고, 시작도 빠르고, 작은 단위의 서비스 배포에 잘 맞습니다.

제가 실무나 홈서버 관점에서 느낀 차이는 이렇습니다.

• 가상머신: 운영체제까지 따로 필요, 무겁지만 독립성이 큼
• 컨테이너: 앱 단위 배포에 유리, 가볍고 빠름
• 홈서버/NAS: 제한된 자원에서 여러 서비스를 띄우려면 컨테이너가 훨씬 효율적

즉, NAS처럼 CPU·메모리가 아주 넉넉하지 않은 환경에서는 Docker가 특히 잘 맞습니다.

Docker에서 자주 보는 핵심 용어 5가지

1) 이미지(Image)

컨테이너를 만들기 위한 템플릿입니다.
예를 들어 nginx, postgres, wordpress 같은 것들이 이미지입니다.

2) 컨테이너(Container)

이미지를 실제로 실행한 상태입니다.
이미지는 설계도, 컨테이너는 실행 중인 인스턴스라고 생각하면 이해가 쉽습니다.

3) 볼륨(Volume)

컨테이너를 지워도 데이터를 남기기 위한 저장소입니다.
DB 데이터, 업로드 파일, 설정 파일은 보통 볼륨에 분리합니다. Docker Engine 문서는 이미지·컨테이너 외에도 볼륨과 네트워크 같은 객체를 daemon이 관리한다고 설명합니다.

4) 네트워크(Network)

컨테이너끼리 통신하거나 외부와 연결될 때 쓰는 가상 네트워크입니다.

5) Compose

여러 컨테이너를 한 번에 정의하는 방식입니다. Docker는 Compose를 단일 YAML 파일로 서비스·네트워크·볼륨을 관리하는 도구로 설명합니다.

Docker Engine과 Synology Container Manager의 관계

이 부분이 가장 중요합니다.

Docker Engine은 실제로 컨테이너를 실행하는 핵심 엔진입니다. Docker 공식 문서에 따르면 Docker Engine은 dockerd 데몬, API, CLI로 구성되고 이미지·컨테이너·네트워크·볼륨 등을 관리합니다.

반면 시놀로지 DSM 7.3의 Container Manager는
NAS 환경에서 컨테이너를 GUI로 다루기 쉽게 만든 관리 레이어라고 보면 됩니다. Synology 공식 문서에서는 Project 메뉴에서 하나 또는 여러 컨테이너로 구성된 프로젝트를 생성·운영·관리할 수 있다고 안내합니다.

즉,

• Docker Engine = 실제 실행 엔진
• Container Manager = NAS에서 쉽게 다루는 관리 화면
• Compose / Project = 여러 컨테이너를 한 세트로 관리하는 방식

이라고 이해하면 거의 맞습니다.

DSM 7.3 Container Manager가 편한 이유

시놀로지 NAS를 쓰는 분이라면 명령어보다 GUI가 편한 순간이 많습니다.

Container Manager의 장점은 이런 쪽에서 크게 느껴집니다.

1) GUI로 이미지 검색과 다운로드가 쉬움

Docker Hub에서 이미지를 찾고 내려받는 과정을 NAS 화면에서 처리할 수 있습니다.

2) 컨테이너 생성이 쉬움

포트, 환경변수, 볼륨 마운트, 재시작 정책 등을 화면에서 입력할 수 있어 초보자 진입장벽이 낮습니다.

3) 로그와 상태 확인이 쉬움

실행 여부, 에러 로그, 리소스 사용 현황을 빠르게 확인할 수 있습니다.

4) Project 방식으로 Compose 운영이 가능함

여러 컨테이너를 하나의 프로젝트처럼 묶어 관리할 수 있어서, 웹앱 + DB 같이 함께 움직여야 하는 구성을 다루기 편합니다. Synology 공식 Project 문서도 이 개념을 지원한다고 설명합니다.

반대로 CLI Docker가 더 좋은 경우

Container Manager가 편하긴 하지만, 모든 상황에서 최고는 아닙니다.

직접 docker 나 docker compose 명령어를 쓰면 좋은 경우도 분명합니다.

1) 재현성이 좋음

Compose 파일 하나만 있으면 다른 서버에서도 거의 같은 구조로 올리기 쉽습니다. Docker Compose는 다중 컨테이너 앱을 YAML로 정의하고 전체 라이프사이클을 관리할 수 있다고 공식 문서가 설명합니다.

2) 백업과 버전관리가 쉬움

설정이 파일로 남기 때문에 Git으로 관리하기 좋습니다.

3) 자동화에 강함

스크립트, CI/CD, 배포 자동화와 연결하기 좋습니다.

4) 옵션을 세밀하게 다루기 좋음

GUI에서 안 보이는 옵션도 CLI로는 직접 제어하기 쉽습니다.

한눈에 비교: Docker CLI vs DSM 7.3 Container Manager

제 경험상

• 처음 시작은 Container Manager
• 구성이 커지면 Compose 파일 관리
  이 흐름이 가장 안정적이었습니다.

실제 예시 1: 가장 쉬운 시작, Nginx 하나 띄워보기

Docker 입문에서 제일 쉬운 예시는 정적 웹서버입니다.

예를 들어 Nginx 컨테이너 하나를 띄우면
“이미지 다운로드 → 컨테이너 실행 → 포트 연결”
이라는 Docker의 핵심 흐름을 빠르게 익힐 수 있습니다.

Docker 공식 문서에서 docker run은 이미지로부터 컨테이너를 실행하는 기본 명령이고, 이미지 참조에는 태그를 붙여 특정 버전을 지정할 수 있다고 설명합니다.

예시 명령은 이런 형태입니다.

docker run -d --name my-nginx -p 8080:80 nginx:latest

이 의미는 다음과 같습니다.

• -d : 백그라운드 실행
• --name my-nginx : 컨테이너 이름 지정
• -p 8080:80 : NAS나 서버의 8080 포트를 컨테이너 80 포트와 연결
• nginx:latest : 실행할 이미지

DSM 7.3 Container Manager에서는?

같은 작업을 GUI로 할 수 있습니다.

1. 이미지 검색에서 nginx 다운로드
2. 새 컨테이너 생성
3. 로컬 포트 8080 → 컨테이너 포트 80 연결
4. 실행
5. 브라우저에서 NAS주소:8080 접속

처음 Docker를 이해할 때는 이 예시 하나만 성공해도 감이 많이 잡힙니다.

실제 예시 2: 웹서비스답게, WordPress + MariaDB 같이 올리기

여기부터는 Compose 개념이 정말 편해집니다.

워드프레스는 단독으로 끝나지 않고 보통

• WordPress 컨테이너
• MariaDB 또는 MySQL 컨테이너
  두 개 이상이 함께 필요합니다.

이런 구조를 각각 따로 만들 수도 있지만, Compose로 관리하면 훨씬 정리됩니다. Compose는 여러 서비스를 한 YAML로 정의하는 방식이고, Docker 공식 빠른 시작도 Python 앱 + Redis 예시로 이런 멀티 컨테이너 구조를 보여줍니다.

아래는 입문용 예시입니다.

services:
  db:
    image: mariadb:11
    container_name: wp-db
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: strong_root_password
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: strong_wp_password
    volumes:
      - ./db_data:/var/lib/mysql  wordpress:
    image: wordpress:php8.2-apache
    container_name: wp-app
    restart: unless-stopped
    depends_on:
      - db
    ports:
      - "8081:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: strong_wp_password
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_data:/var/www/html

이 예시에서 중요한 포인트

• services 아래에 앱과 DB를 같이 정의
• depends_on으로 실행 순서를 어느 정도 정리
• volumes로 데이터를 컨테이너 밖에 보관
• 포트 8081:80으로 워드프레스 접속 가능

DSM 7.3 Container Manager에서는?

Project 기능에서 이런 YAML 기반 구성을 가져와 관리할 수 있습니다. Synology 공식 문서도 Project가 하나 또는 여러 컨테이너로 구성된 프로젝트를 생성·관리하는 메뉴라고 설명합니다.

즉, NAS에서도
“단순 GUI 클릭”만이 아니라
“Compose 스타일의 프로젝트 운영”이 가능하다는 점이 꽤 큰 장점입니다.

시놀로지 NAS에서 Docker를 쓸 때 특히 좋은 사례

제가 보기엔 DSM 7.3 Container Manager는 아래 같은 용도에서 특히 강합니다.

1) 홈서버 서비스 운영

• 워드프레스
• n8n
• Jellyfin
• Joplin Server
• Grafana
• Portainer

2) 작은 사내 서비스 테스트

• 내부용 웹앱
• API 서버
• 대시보드
• DB 실험 환경

3) 개발·검증용 분리 환경

같은 NAS 안에서도 프로젝트별로 분리해서 돌리기 좋습니다.

특히 시놀로지는 파일 접근, 폴더 권한, 백업 구조를 NAS 친화적으로 관리할 수 있어서 “홈랩 + 운영 연습” 용도로 꽤 괜찮습니다.

Docker를 처음 쓸 때 가장 많이 하는 실수

실제로 처음 할 때는 기술 자체보다 운영 습관에서 문제가 많이 납니다.

1) 데이터를 컨테이너 안에만 저장함

컨테이너 삭제 시 데이터가 같이 날아갈 수 있습니다.
DB, 업로드 파일, 설정 파일은 볼륨 또는 바인드 마운트로 분리하는 습관이 중요합니다. Docker Engine 문서도 persistent data에 volume 사용을 안내합니다.

2) 포트 충돌을 확인하지 않음

NAS에서 80, 443, 8080, 5000 계열 포트는 이미 다른 서비스가 쓰고 있을 수 있습니다.

3) latest 태그만 무조건 사용함

처음에는 편하지만, 나중에 버전이 달라져 예기치 않은 변경이 생길 수 있습니다. Docker 문서도 이미지 참조에 태그를 써서 특정 버전을 지정할 수 있다고 설명합니다.

4) 환경변수를 정리하지 않음

비밀번호나 설정값을 하드코딩하면 나중에 관리가 어렵습니다.

5) 백업을 안 함

Compose 파일, 데이터 폴더, DB 덤프는 반드시 따로 백업하는 습관이 필요합니다.

입문자에게 추천하는 시작 순서

처음이면 너무 어렵게 가지 않는 게 좋습니다.

1단계

Container Manager에서 Nginx 하나 띄워보기

2단계

볼륨 마운트와 포트 매핑 이해하기

3단계

환경변수 넣는 컨테이너 실행해보기
예: DB, 워드프레스

4단계

Project 기능으로 Compose 스타일 구성 써보기

5단계

나중에는 YAML 파일을 따로 관리하면서 버전관리까지 연결하기

이렇게 가면 GUI의 편의성과 Docker 본질 둘 다 잡을 수 있습니다.

결국 무엇이 더 좋을까

정리하면 이렇습니다.

Docker는 컨테이너를 실행하는 기술 자체이고,
DSM 7.3 Container Manager는 그 기술을 시놀로지 NAS에서 쉽게 다루는 도구입니다. Docker는 애플리케이션을 컨테이너로 패키징해 실행하게 해주고, Docker Compose는 여러 서비스를 하나의 YAML로 정의·운영하게 해주며, Synology의 Project 기능은 이런 멀티 컨테이너 구성을 NAS GUI에서 관리하는 데 초점을 둡니다.

그래서 제 추천은 단순합니다.

• 처음 배우는 단계라면 → DSM 7.3 Container Manager부터
• 반복 배포와 구조화가 필요해지면 → Compose 파일 관리까지
• 실무형으로 확장하고 싶다면 → CLI와 YAML 중심으로 이동

처음부터 명령어만 붙잡고 씨름할 필요는 없습니다.
반대로 GUI만 쓰다 보면 구조를 놓칠 수도 있습니다.
가장 좋은 방법은 시놀로지 GUI로 감을 잡고, 나중에 Compose로 정리하는 흐름입니다.

이 방식이 홈서버 운영에도 좋고, 나중에 리눅스 서버나 클라우드로 넘어갈 때도 가장 자연스럽습니다.

마무리

Docker를 배우면 단순히 “앱 하나 실행하는 법”만 익히는 게 아닙니다.
서비스를 더 깔끔하게 배포하고, 더 쉽게 옮기고, 더 안정적으로 관리하는 방식을 배우게 됩니다.

시놀로지 NAS의 DSM 7.3 Container Manager는 그 첫걸음을 꽤 쉽게 만들어줍니다.
특히 홈서버, 개인 블로그, 자동화 도구, DB 실험 환경, 내부 웹서비스를 운영하려는 분들에게는 정말 좋은 입문 도구입니다.

저도 처음에는 NAS에서 GUI로 시작했지만, 나중에는 Compose 파일을 직접 관리하는 쪽이 훨씬 편해졌습니다.
그래서 처음 시작하시는 분이라면 이렇게 말씀드리고 싶습니다.

“Container Manager로 시작하고, Docker Compose로 정리해가면 됩니다.”

그 흐름만 잡혀도 Docker가 훨씬 덜 어렵게 느껴질 겁니다.

게시물 Docker란 무엇인가? 시놀로지 NAS DSM 7.3 Container Manager와 함께 이해하는 실전 입문 가이드이 하우인포-IT·테크에 처음 등장했습니다.

메모리 반도체 가격 상승이 스마트폰, PC, 서버, 자동차 등 전자제품 가격을 동시에 끌어올리는 현상을 의미합니다.

최근 시장 조사에 따르면 PC용 DRAM 가격이 1년 사이 약 7배 상승했습니다.

이러한 가격 상승은 단순한 공급 부족이 아니라 AI 산업의 폭발적인 성장과 데이터센터 투자 확대 때문으로 분석되고 있습니다.

이번 글에서는

• 메모리 가격 폭등의 구조적 원인
• 글로벌 IT 기업 가격 인상 사례
• ‘램테크’라는 새로운 투자 트렌드
• 자동차 산업까지 확산되는 영향
• 향후 반도체 시장 전망

을 국내외 시장 분석과 기술 흐름을 기반으로 정리했습니다.

메모리플레이션이란 무엇인가

메모리플레이션은 메모리 반도체 가격 상승이 IT 제품 가격 상승으로 이어지는 현상입니다.

대표적인 메모리 반도체는 다음과 같습니다.

DRAM

컴퓨터와 스마트폰에서 작업용 메모리로 사용됩니다.

NAND Flash

SSD와 스마트폰 저장공간에 사용되는 데이터 저장 메모리입니다.

최근 AI 산업 성장으로 이 두 가지 메모리의 수요가 크게 증가했습니다.

PC용 DRAM 가격이 7배 상승한 이유

최근 시장에서 가장 큰 변화는 범용 DRAM 가격 폭등입니다.

대표적인 PC 메모리

DDR4 8Gb DRAM

가격 변화

2025년
약 1.6달러

2026년
약 11~17달러

즉 1년 사이 최대 7배 상승했습니다.

이러한 상승에는 몇 가지 핵심 원인이 있습니다.

AI 데이터센터가 메모리를 빨아들이고 있다

현재 전 세계 빅테크 기업들은 AI 데이터센터 투자 경쟁을 벌이고 있습니다.

대표 기업

• Microsoft
• Google
• Amazon
• Meta
• OpenAI

이 기업들은 AI 모델 학습을 위해 대규모 GPU 서버를 구축하고 있습니다.

AI 서버 특징

일반 서버보다

메모리 사용량이 10배 이상

많습니다.

특히 GPU 서버에는

• DDR5 메모리
• HBM 메모리
• 초고속 SSD

가 대량으로 사용됩니다.

이 때문에 메모리 수요가 폭발적으로 증가했습니다.

메모리 제조사 전략 변화

메모리 시장은 현재 3개 기업이 대부분을 공급합니다.

주요 기업

• 삼성전자
• SK하이닉스
• 마이크론

이 기업들은 최근 생산 전략을 바꾸고 있습니다.

과거

범용 DRAM 중심

현재

AI용 메모리 중심

대표적인 AI 메모리

HBM (High Bandwidth Memory)

HBM은 GPU와 함께 사용되는 고성능 메모리입니다.

AI 시장이 성장하면서 제조사들은 HBM 생산을 늘리고 일반 DRAM 생산을 줄이고 있습니다.

그 결과 PC와 스마트폰용 메모리 공급이 줄어 가격이 상승했습니다.

스마트폰 가격 상승의 숨은 이유

메모리 가격 상승은 스마트폰 가격에도 직접 영향을 주고 있습니다.

과거 스마트폰 원가 구조

메모리 비중
약 10~15%

현재

약 30% 수준

으로 증가한 것으로 업계는 분석합니다.

AI 기능이 강화되면서

• 메모리 용량 증가
• 저장공간 증가
• AI 연산 기능

이 추가됐기 때문입니다.

최근 일부 프리미엄 스마트폰은

200만 원을 넘어가는 가격

까지 등장했습니다.

노트북과 PC 가격도 상승 중

AI PC 시대가 시작되면서 노트북 가격도 빠르게 상승하고 있습니다.

AI PC 특징

• 32GB 이상 메모리
• NPU AI 프로세서
• 대용량 SSD

이러한 구조 때문에 노트북 원가가 크게 증가했습니다.

최근 프리미엄 노트북은

300만 ~ 400만 원대

가격도 등장하고 있습니다.

중고 시장에서 등장한 ‘램테크’

최근 IT 커뮤니티와 중고 거래 시장에서는 새로운 트렌드가 나타났습니다.

바로 램테크(RAM + 재테크) 입니다.

의미

메모리를 미리 구매해 두었다가 가격 상승 후 판매하는 방식입니다.

실제로 중고 거래 플랫폼에서는

• DDR4
• DDR5
• 서버용 메모리

거래량이 수백 퍼센트 증가했습니다.

일부 시장에서는 자동화 프로그램이 메모리를 대량 구매하는 현상도 보고되었습니다.

맥미니 사재기 현상

최근 해외 IT 커뮤니티에서는 맥미니 사재기 현상도 나타났습니다.

이유는 간단합니다.

맥미니 기본 모델에는

• 16GB 메모리
• Apple Silicon 칩

이 탑재되어 있는데 제품 가격 대비 성능이 매우 높기 때문입니다.

일부 사용자들은

• 가격 상승 전에 구매
• 중고 재판매

목적으로 제품을 확보하고 있습니다.

자동차 산업까지 영향 가능성

메모리플레이션은 IT 산업을 넘어 자동차 산업에도 영향을 줄 가능성이 있습니다.

최근 자동차에는

• 자율주행 시스템
• ADAS
• 차량용 OS
• 인포테인먼트

등이 들어갑니다.

이 시스템들은 모두 반도체와 메모리를 필요로 합니다.

만약 차량용 메모리 공급이 부족해지면

• 자동차 생산 지연
• 차량 가격 상승

같은 문제가 발생할 수 있습니다.

메모리 슈퍼사이클이 시작됐을까

반도체 업계에서는 현재 상황을

“메모리 슈퍼사이클”

초기 단계로 보는 의견도 있습니다.

전문가 전망

2026년 메모리 시장 성장률

약 30% 이상

AI용 메모리 시장은

연평균 30% 성장

할 것으로 예상됩니다.

소비자가 알아야 할 변화

현재 메모리플레이션은 단순한 가격 상승이 아닙니다.

앞으로는

• 스마트폰
• PC
• 서버
• 자동차

모든 전자 제품에서 반도체 가격이 핵심 변수가 될 가능성이 높습니다.

소비자 행동도 바뀌고 있습니다.

대표 사례

• 전자제품 미리 구매
• 부품 투자
• 중고 거래 증가

앞으로 메모리 가격 전망

전문가들은 메모리 가격 상승이 단기간에 끝나지 않을 가능성이 높다고 보고 있습니다.

이유

1️⃣ AI 데이터센터 투자 확대
2️⃣ GPU 서버 증가
3️⃣ HBM 수요 폭증
4️⃣ 신규 반도체 공장 건설 지연

일부 신규 공장은

2027년 이후

에야 본격 생산을 시작할 예정입니다.

즉 당분간 공급 부족 상황이 지속될 가능성이 있습니다.

핵심 정리

현재 IT 산업에서는 메모리 중심 경제 구조가 형성되고 있습니다.

핵심 변화

• DRAM 가격 1년 사이 최대 7배 상승
• AI 데이터센터가 메모리 수요 폭증
• 스마트폰·PC 가격 상승
• 중고 시장 ‘램테크’ 등장
• 자동차 산업까지 영향 가능성

AI 시대가 본격화되면서 메모리 반도체는 석유와 비슷한 전략 자원이 될 가능성도 있습니다.

FAQ

메모리플레이션이란 무엇인가요

메모리 반도체 가격 상승이 IT 제품 가격 상승으로 이어지는 현상을 의미합니다.

왜 DRAM 가격이 갑자기 상승했나요

AI 데이터센터 확대로 메모리 수요가 급증했기 때문입니다.

앞으로 스마트폰 가격이 계속 오를까요

AI 기능과 메모리 증가 때문에 프리미엄 스마트폰 가격 상승 가능성이 높습니다.

램테크는 실제로 가능한 투자 방법인가요

가격 변동이 큰 부품 시장이기 때문에 단기적인 수익 가능성은 있지만 안정적인 투자 방식은 아닙니다.

게시물 메모리플레이션 시대: D램 가격 7배 폭등이 IT 시장을 뒤흔드는 이유이 하우인포-IT·테크에 처음 등장했습니다.

1) 준비물 체크

• Windows 11 (Pro/Home 무관)
• Docker Desktop 설치 완료 (docker ps가 에러 없이 동작해야 함)
• 공유기: ipTIME (KT 회선 환경 가정)
• 접속 클라이언트: 안드로이드 Minecraft(베드락)

2) BDS 기본 포트(중요)

베드락 서버 기본 포트는 다음과 같습니다.

• UDP 19132 (게임 접속 포트)

즉, 내부/외부 모두 UDP 19132만 제대로 열리면 접속이 됩니다.

3) Docker로 BDS 설치(Compose 방식)

3-1. 서버 폴더 만들기 (월드/설정 영구 저장)

예시: D:\minecraft\bedrock

PowerShell:

mkdir D:\minecraft\bedrock
cd D:\minecraft\bedrock

3-2. docker-compose.yml 만들기

D:\minecraft\bedrock\docker-compose.yml 파일을 만들고 아래 내용을 그대로 붙여넣습니다.

services:
  bds:
    image: itzg/minecraft-bedrock-server:latest
    container_name: mc-bedrock
    ports:
      - "19132:19132/udp"
    environment:
      EULA: "TRUE"
      SERVER_NAME: "Howinfo Bedrock Server"
      GAMEMODE: "survival"
      DIFFICULTY: "normal"
      LEVEL_NAME: "HowinfoWorld"
      MAX_PLAYERS: "10"
      ONLINE_MODE: "true"
      TZ: "Asia/Seoul"
    volumes:
      - ./data:/data
    restart: unless-stopped

3-3. 서버 실행

docker compose up -d

정상 동작 확인:

docker ps
docker logs -f mc-bedrock

• docker ps에서 mc-bedrock이 Running이면 1차 성공
• docker logs -f에서 심각한 에러 없이 대기 상태로 들어가면 OK

4) Windows 방화벽 열기 (UDP 19132)

서버 PC(Windows 11)에서 방화벽이 막고 있으면, 같은 집에서도 접속이 안 될 수 있습니다.

Windows 보안 → 방화벽 및 네트워크 보호 → 고급 설정 → 인바운드 규칙 → 새 규칙

• 규칙 유형: 포트
• 프로토콜: UDP
• 포트: 19132
• 허용
• 프로필: 보통 개인(Private) 포함(필요 시 도메인도)
• 이름 예: Minecraft Bedrock UDP 19132

5) 안드로이드에서 “같은 와이파이”로 접속 확인 (내부 접속)

외부 설정 전에 먼저 내부에서 정상 접속되는지 확인하는 게 가장 빠릅니다.

5-1. 서버 PC 내부 IP 확인

PowerShell:

ipconfig

예: 192.168.0.15

5-2. 안드로이드 Minecraft에서 서버 추가

Minecraft(베드락) → 플레이 → 서버 → 서버 추가 (핸드폰에서 연결할 서버주소 또는 도메인 직접 입력)

• 서버 이름: 아무거나
• 서버 주소: 192.168.0.15 (서버 PC 내부 IP)
• 포트: 19132

✅ 같은 와이파이에서 접속이 되면, BDS 설치/컨테이너/방화벽은 거의 끝난 것입니다.

6) ipTIME 공유기 포트포워딩(외부 접속) 설정

이제 집 밖(모바일 데이터, 회사, 외부 PC)에서도 접속되게 하려면 공유기에서 포트를 열어야 합니다.

6-1. 서버 PC 내부 IP 고정(권장)

서버 PC의 내부 IP가 바뀌면 포트포워딩이 무용지물이 됩니다.

• ipTIME 관리자 페이지 접속(보통 192.168.0.1)
• DHCP 서버 설정 / 주소 예약 메뉴에서
  서버 PC의 MAC 주소에 192.168.0.15처럼 고정 예약 권장

6-2. 포트포워딩 추가

ipTIME 관리자 페이지 → NAT/라우터관리 → 포트포워드

• 프로토콜: UDP
• 외부 포트: 19132
• 내부 IP: 서버 PC 내부 IP (예: 192.168.0.15)
• 내부 포트: 19132

저장 후 적용

7) 집 밖(외부)에서 접속 확인

7-1. 공인 IP 확인

서버 PC 또는 휴대폰에서 “내 IP” 검색(공인 IP 확인)
외부 접속 테스트 시 주소로 사용합니다.

7-2. 안드로이드에서 모바일 데이터로 접속 테스트

안드로이드에서 와이파이를 끄고(모바일 데이터로 전환) Minecraft → 서버 추가:

• 서버 주소: 공인 IP
• 포트: 19132

✅ 모바일 데이터에서 접속되면 외부 접속까지 성공입니다.

8) 외부 접속이 안 될 때(가장 흔한 원인 3가지)

1. UDP 포트포워딩을 TCP로 걸어둔 경우
   • 베드락은 기본이 UDP입니다. 포워딩 프로토콜이 UDP인지 다시 확인하세요.
2. Windows 방화벽 규칙 누락
   • UDP 19132 인바운드가 실제로 허용됐는지 재확인
3. 이중 NAT (KT 장비 + ipTIME)
   • KT 모뎀/공유기가 라우팅을 하고, ipTIME도 라우팅을 하면 “겹 NAT”가 생겨 외부 접속이 막히는 경우가 있습니다.
   • 이때 해결 방법은 보통:
     • KT 장비를 브릿지 모드로 전환하거나
     • KT 장비에서 ipTIME을 DMZ로 지정하거나
     • ipTIME을 AP 모드로 전환(권장 시나리오에 따라 다름)

외부 접속이 막히면, 집 네트워크 구조(“KT 장비가 따로 있는지”)부터 확인하는 게 제일 빠릅니다.

9) 운영 팁(최소한만)

• 서버 재시작:

docker restart mc-bedrock

• 서버 종료/시작:

docker stop mc-bedrock
docker start mc-bedrock

• 데이터(월드/설정) 저장 위치:
  • D:\minecraft\bedrock\data\
    이 폴더만 백업하면 됩니다(서버 중지 후 압축 권장).

마무리

정리하면, Windows 11에서 Docker로 BDS 운영은 아래 순서로 끝납니다.

1. Docker Compose로 BDS 실행
2. Windows 방화벽 UDP 19132 허용
3. 안드로이드(같은 와이파이) 접속 확인
4. ipTIME UDP 19132 포트포워딩
5. 안드로이드(모바일 데이터)로 외부 접속 확인

여기까지 되면 “서버가 실제로 운영 가능한 상태”입니다.

게시물 너무나 쉬운 윈도우즈11+docker 이용 베드락 마인크래프트 설치하고 외부에서 접근하여 게임즐기기이 하우인포-IT·테크에 처음 등장했습니다.

저는 미니스포럼 N5 Pro 같은 저전력·고효율 미니PC를 홈서버/NAS 보조 서버로 쓰는 경우가 많은데, 이때 Windows 11 Pro에서 Docker를 가장 쾌적하게 돌리는 방식은 Docker Desktop + WSL 2 백엔드 조합이었습니다.

이 글은 초보자도 그대로 따라 하면 설치가 끝나는 흐름으로 정리했고, 실제로 많이 막히는 오류 해결까지 함께 넣었습니다. (붙여넣기용 완성본)

1) 오늘 설치할 구성 (핵심 요약)

• Windows 11 Pro
• WSL 2 활성화
• Docker Desktop 설치 (WSL 2 백엔드 사용)
• docker run hello-world로 최종 검증
• 오류 발생 시 체크 순서 제공

2) 사전 준비 체크 (여기서 80%가 결정됩니다)

(1) BIOS 가상화(VT-x/AMD-V) 활성화 확인

WSL 2와 Docker는 가상화 기능에 의존합니다.

• BIOS 메뉴에서 아래 항목이 Enabled인지 확인
  • Intel Virtualization Technology (VT-x)
  • 또는 SVM / AMD-V

✅ 증상 힌트

• 가상화가 꺼져 있으면 WSL 설치가 되더라도 Docker가 정상 실행되지 않거나, WSL이 1로 떨어지는 경우가 있습니다.

(2) Windows 기능 켜기 (필수)

시작 메뉴 → “Windows 기능 켜기/끄기” 검색 후 실행, 아래 항목을 체크합니다.

• Linux용 Windows 하위 시스템
• 가상 머신 플랫폼
• (Pro라면 켜두면 좋은 편) Hyper-V

체크 후 [확인] → 재부팅

✅ 포인트

• WSL 2는 “가상 머신 플랫폼”이 꺼져 있으면 정상 동작이 어렵습니다.
• Hyper-V는 WSL 2 백엔드에서도 환경에 따라 도움이 됩니다(특히 회사 PC/보안정책 환경).

3) WSL 2 설치 및 업데이트 (PowerShell 관리자)

PowerShell을 관리자 권한으로 실행합니다.

(1) WSL 설치/업데이트

wsl --install
wsl --update

(2) WSL 기본 버전 2 고정

wsl --set-default-version 2

(3) WSL 상태 확인(선택)

wsl --status
wsl -l -v

✅ 여기서 확인할 것

• wsl -l -v 출력에서 배포판이 보이고, VERSION이 2인지 확인

4) 리눅스 배포판(Ubuntu) 설치 (없으면 반드시)

wsl -l -v에서 배포판이 하나도 없다면 Ubuntu를 설치합니다.

wsl --install -d Ubuntu

설치 후 Ubuntu를 한 번 실행하면 Linux 사용자 이름/비밀번호를 설정하는 단계가 나옵니다.
(비밀번호는 입력해도 화면에 안 보이는 게 정상입니다)

5) Docker Desktop 설치 (WSL 2 백엔드로)

(1) 설치 파일 실행

Docker Desktop Installer.exe 실행

(2) 설치 중 가장 중요한 옵션

설치 과정에서 아래 옵션이 나오면 반드시 체크된 상태로 진행합니다.

• ✅ Use WSL 2 instead of Hyper-V (recommended)

(3) 설치 완료 후 재부팅

설치가 끝나면 Close and restart로 재부팅합니다.

6) Docker Desktop 설정 확인 (WSL 통합)

재부팅 후 Docker Desktop 실행 → Settings에서 확인합니다.

• Settings → Resources → WSL Integration
  • Ubuntu(또는 설치한 배포판)에 대해
  • ✅ Enable integration 켬

✅ 추천

• 배포판이 여러 개라면, 실제 사용할 배포판 하나만 통합 켜두는 게 관리가 편합니다.

7) 설치 확인 테스트 (여기까지 오면 끝)

PowerShell 또는 Windows Terminal에서 실행합니다.

(1) 버전 확인

docker --version

(2) hello-world 테스트

docker run hello-world

아래 문구가 나오면 성공입니다.

• Hello from Docker!

8) 오류 해결 모음 (실제로 제일 많이 막히는 구간)

아래는 “증상 → 원인 → 해결” 순서로 정리했습니다.

오류 1) docker 명령어가 인식되지 않음

증상

• docker : The term 'docker' is not recognized...

원인

• Docker Desktop 설치가 안 되었거나, 재부팅 전 상태이거나, PATH 적용이 안 된 케이스

해결

1. Docker Desktop이 설치되어 있는지 확인
2. 재부팅 1회
3. 그래도 안 되면 Docker Desktop 재설치

오류 2) WSL 2 installation is incomplete

증상

• Docker Desktop 실행 시 WSL 2 커널 관련 경고

원인

• WSL 업데이트/Windows 업데이트 미반영 또는 재부팅 누락

해결

1. PowerShell(관리자) 실행

wsl --update

2. 재부팅
3. Windows Update 최신 상태 확인(선택)

오류 3) wsl -l -v에서 VERSION이 1로 뜸

원인

• 기본 버전이 2로 고정되지 않았거나, 배포판이 1로 생성된 상태

해결

wsl --set-default-version 2
wsl --set-version Ubuntu 2

오류 4) 0x80370102 / “가상 머신 플랫폼” 관련 오류

증상

• WSL 실행/설치 중 가상화 관련 오류 코드 발생

원인

• BIOS 가상화 꺼짐, Windows 기능 미활성화, 보안 기능 충돌

해결 체크 순서

1. BIOS VT-x/AMD-V Enabled
2. Windows 기능: Linux용 Windows 하위 시스템 / 가상 머신 플랫폼 체크
3. 재부팅
4. PowerShell 관리자에서 wsl --update

오류 5) docker run hello-world가 다운로드에서 멈춤

원인

• 회사망/프록시/방화벽/DNS 이슈가 흔함

해결

• 집 인터넷/모바일 핫스팟에서 한 번 테스트
• Docker Desktop의 네트워크/프록시 설정 확인
• 회사 PC라면 보안 정책상 Docker 허용 여부 확인 필요

오류 6) Docker Desktop이 “Starting…”에서 멈춤

원인

• WSL 통합 문제, 배포판 손상, 업데이트 충돌

해결(가벼운 순서)

1. Docker Desktop 종료 후 재실행
2. 재부팅
3. PowerShell 관리자:

wsl --shutdown

4. Docker Desktop 다시 실행
5. 그래도 안 되면 WSL 배포판 재설치 고려(마지막 수단)

9) 설치 후 추천: 홈서버/NAS 운영에 바로 쓰는 기본 명령어

컨테이너 목록 보기

docker ps
docker ps -a

이미지 목록 보기

docker images

컨테이너 중지/삭제

docker stop <컨테이너ID>
docker rm <컨테이너ID>

이미지 삭제

docker rmi <이미지ID>

10) 마무리 (제가 이 구성을 추천하는 이유)

Windows 11 Pro에서 Docker를 운영할 때, Hyper-V 기반으로도 가능하지만
실사용(특히 미니PC/홈서버)에서는 WSL 2 백엔드가 설치·유지보수 난이도가 낮고 안정적인 편이었습니다.

• 개발 환경(리눅스 도구)도 WSL에서 자연스럽게 이어지고
• 컨테이너 운영도 Docker Desktop에서 시각적으로 관리 가능해서
• “홈서버 운영 + 개발” 둘 다 잡기 좋았습니다.

게시물 Windows 11 Pro Docker 설치 가이드 (WSL 2 백엔드) + 오류 해결이 하우인포-IT·테크에 처음 등장했습니다.

NAS는 결국 “필요할 때만 켜서 쓰고, 평소엔 꺼두는” 운영이 핵심이죠.
그런데 윈도우 11 Pro 설치 후 기본 설정만으로는 WOL이 안 되는 경우가 정말 많습니다.
저도 “다 설정했는데 왜 안 켜지지?”를 반복하다가, 결론적으로 아래 2개가 핵심 원인이었습니다.

• BIOS의 ErP Ready
• 윈도우의 빠른 시작(Fast Startup)

게다가 외부에서 깨우려면 ipTIME 공유기 설정까지 연결되어야 완성됩니다.
이 글 하나로 **BIOS → Windows → ipTIME(외부 WOL)**까지 끝낼 수 있게 구성해볼게요.

요약

1. BIOS에서 ErP Ready = Disabled, Wake on PCI-E = Enabled
2. Windows에서 랜카드 Wake on Magic Packet = Enabled, 전원관리에서 매직 패킷만 허용
3. Windows 전원 옵션에서 ‘빠른 시작 켜기’ 해제
4. ipTIME은 **WOL 기능 + DDNS(원격 접속)**로 외부에서도 깨우기

1. WOL이 안 되는 대표 증상 (제가 겪었던 것들)

아래 중 하나라도 해당되면, 거의 확실히 이 글의 설정이 필요합니다.

• 절전(Sleep)에서는 깨우는데 종료(Shut down) 후에는 WOL이 안 됨
• 종료 후 랜포트 LED가 꺼지거나 링크가 사라짐
• 같은 집(내부망)에서는 되는데 외부(LTE/회사)에서는 안 됨
• 어떤 날은 되고 어떤 날은 안 됨 (대개 빠른 시작/드라이버 전원정책 영향)

2. BIOS 설정 (전원 꺼져도 랜카드가 살아있게 만들기)

목표는 딱 하나입니다.
PC가 꺼져 있어도(Soft Off) 랜카드가 전원을 유지하고 매직패킷을 받을 수 있게 하는 것.

2-1) BIOS 진입

• 부팅 시 Del 키 연타

2-2) ErP Ready 비활성화 (가장 중요)

• Advanced → ACPI Settings
• ErP Ready = Disabled

ErP가 켜져 있으면 대기전력을 줄이려고 랜카드 전원까지 차단하는 경우가 많습니다.
이 상태에서는 WOL 신호가 와도 받을 수가 없습니다.

2-3) WOL 활성화 (PCI-E Wake)

아래 중 하나로 보이는 항목을 찾아 켭니다(보드/BIOS마다 명칭이 조금 다름).

• Wake configuration
• Resume By PCI-E Device
• Wake on PCI-E
• Wake on LAN

→ 해당 항목을 Enabled

2-4) 저장 후 재부팅

• F10 → Save & Exit

✅ BIOS 체크포인트(매우 유용)
PC를 “종료”한 뒤, 랜포트 LED가 살아있는지 보세요.
LED가 완전히 꺼진다면 ErP나 전원 항목이 아직 막고 있을 가능성이 큽니다.

3. Windows 11에서 네트워크 어댑터 WOL 설정

BIOS가 준비되었으면, 이제 Windows가 랜카드를 “깨울 수 있는 장치”로 허용해야 합니다.

3-1) 장치 관리자 열기

• 시작 버튼 우클릭 → 장치 관리자
• 네트워크 어댑터 펼치기
• 사용 중인 유선 어댑터(예: Realtek PCIe 2.5GbE) 우클릭 → 속성

3-2) [고급] 탭 설정

• Wake on Magic Packet = Enabled
• (있다면) Shutdown Wake-On-LAN = Enabled
• (있다면) Wake on pattern match = Disabled 권장
  → 원치 않는 트래픽에 혼자 켜지는 현상을 줄여줍니다.

3-3) [전원 관리] 탭 설정

아래 두 개는 거의 필수입니다.

• ✅ “이 장치를 사용하여 컴퓨터의 대기 모드를 종료할 수 있음” 체크
• ✅ “매직 패킷에서만 컴퓨터의 대기 모드를 종료할 수 있음” 체크

두 번째 체크가 없으면, 네트워크 브로드캐스트/스캔 패킷에 의해 의도치 않게 켜질 수 있습니다.

4. 결정타: ‘빠른 시작(Fast Startup)’ 끄기

윈도우 10/11의 빠른 시작은 종료를 완전 종료가 아니라 “하이브리드 종료”처럼 만들어서,
환경에 따라 종료 후 WOL이 무시되는 경우가 꽤 많습니다.

4-1) 빠른 시작 해제 경로

• 제어판 → 하드웨어 및 소리 → 전원 옵션
• 좌측 전원 단추 작동 설정
• 상단 ‘현재 사용할 수 없는 설정 변경’ 클릭
• 하단 [빠른 시작 켜기(권장)] 체크 해제
• 저장

✅ 실전 팁
“절전은 되는데 종료는 안 됨”이면, 이 단계가 진짜 마지막 퍼즐일 가능성이 큽니다.

5. 내부망(집 안)에서 먼저 WOL 테스트하기

외부 WOL로 바로 가지 말고, 먼저 집 안에서 성공시키는 게 순서입니다.

• 스마트폰 WOL 앱 또는 PC 도구로 같은 와이파이/내부망에서 매직패킷 전송
• N5 Pro가 켜지면 → Windows/BIOS는 성공
• 안 켜지면 → 2~4단계를 다시 점검

6. ipTIME 공유기에서 외부 WOL 완성하기 (진짜 NAS 운영의 핵심)

이제 핵심입니다.
집 안에서는 되었는데 외부에서 안 된다면, 대부분 ipTIME에서 아래 이슈 때문입니다.

• PC가 꺼지면 공유기 ARP 테이블에서 MAC↔IP 정보가 사라짐
• 외부에서 들어온 매직패킷이 내부 브로드캐스트로 전달되지 않음

그래서 ipTIME 환경에서는 가장 안정적으로 “공유기의 WOL 기능”을 쓰는 방식을 추천합니다.

6-1) 사전 준비: 고정 IP + MAC 주소 확보

외부 WOL은 “고정 IP”가 거의 필수입니다.

① MAC 주소 확인

• cmd 실행 → ipconfig /all
• “물리적 주소(Physical Address)” 확인
  예: AA-BB-CC-DD-EE-FF

② ipTIME에서 DHCP 고정할당(권장)

• 관리자 페이지 접속: 192.168.0.1
• 메뉴 예시: 고급 설정 → 네트워크 관리 → 내부 네트워크 설정(DHCP 서버)
• DHCP 고정할당 / IP-MAC 바인딩 메뉴에서
  N5 Pro MAC 주소 등록 + 고정 IP(예: 192.168.0.15) 지정

✅ 이걸 해두면 WOL 목록 등록/ARP 유지가 훨씬 안정적입니다.

6-2) ipTIME WOL 기능으로 내부 WOL 등록

• 192.168.0.1 접속 후 로그인
• WOL 메뉴(펌웨어/모델에 따라 다름)
  • 고급 설정 → 특수 기능 → WOL
  • 또는 시스템 관리 → 기타 설정 → WOL

WOL 목록에 N5 Pro 등록

• 장치 이름: N5Pro-NAS
• MAC 주소: 위에서 확인한 값 입력
• (필요 시) IP 주소도 함께 입력
• 저장

6-3) 외부에서 깨우는 방법 1 (가장 단순): ipTIME DDNS + 원격 접속 후 WOL 버튼

ipTIME 공유기 관리페이지에 외부에서 들어가서 “WOL 버튼”을 누르는 방식입니다.
구성이 단순하고 성공률도 높습니다.

① ipTIME DDNS 설정

• 고급 설정 → 특수 기능 → DDNS 설정
• ipTIME 계정으로 DDNS 도메인 생성
  예: myhome.iptime.org

② 원격관리(외부 접속) 설정

• 고급 설정 → 시스템 관리 → 원격 관리(또는 웹 관리)
• 원격 관리 활성화
• 관리 포트는 꼭 변경(보안상 매우 중요)
  예: 8443 같은 값으로 변경

③ 외부에서 접속해서 WOL 실행

• 외부(모바일 LTE)에서 브라우저로 접속
  myhome.iptime.org:8443
• 로그인 → WOL 메뉴 → N5Pro-NAS 깨우기 실행

✅ 장점

• 복잡한 브로드캐스트/포트포워딩보다 성공률 높음
• 공유기가 내부로 매직패킷을 뿌려주므로 안정적

⚠️ 보안 팁(꼭!)

• 관리자 비번 강하게
• 원격관리 포트 변경 필수
• 가능하면 원격관리 허용 IP 제한(기능이 있다면) 사용 권장

6-4) 외부에서 깨우는 방법 2 (실전 최강 안정성): 내부 “대리 송신기” 구성

저는 개인적으로 이 방식이 가장 마음 편했습니다.

• 집에 항상 켜져 있는 장치(시놀로지/오렌지파이/라즈베리파이)가 있다면
• 외부에서 그 장치로 접속(SSH/VPN) → 내부에서 WOL 송신

✅ 장점

• 공유기 브로드캐스트/ARP 문제를 대부분 회피
• 공유기 원격관리 포트를 외부에 열지 않아도 되는 경우가 많아 보안도 좋음

7. 최종 점검 체크리스트 (이대로만 하면 됩니다)

BIOS

• ErP Ready = Disabled
• Wake on LAN / Resume by PCI-E = Enabled
• 종료 후 랜포트 LED가 살아있음

Windows (장치 관리자)

• Wake on Magic Packet = Enabled
• (있으면) Shutdown WOL = Enabled
• 전원 관리: “장치로 깨우기” 체크
• 전원 관리: “매직 패킷만” 체크

Windows (전원 옵션)

• 빠른 시작 끔

ipTIME(외부 WOL)

• DHCP 고정할당으로 내부 IP 고정
• ipTIME WOL 목록에 MAC 등록
• (선택) DDNS + 원격관리 포트 변경 후 외부에서 WOL 실행
  또는
• (강추) 내부 대리 송신기(홈서버/나스/라즈베리파이) 구성

8. 자주 묻는 질문(FAQ)

Q1. 절전에서는 되는데 종료에서는 안 돼요.

• 빠른 시작이 켜져 있거나
• 드라이버에서 Shutdown WOL이 꺼져 있거나
• BIOS ErP가 켜져 있을 가능성이 큽니다.
  → 이 글의 2~4장 순서대로 다시 체크하세요.

Q2. 집에서는 되는데 밖에서는 안 돼요.

• 공유기의 ARP/브로드캐스트 이슈일 가능성이 큽니다.
  → ipTIME WOL 기능 + DDNS 원격 접속 방식을 쓰면 성공률이 올라갑니다.
  → 가장 안정적인 건 “내부 대리 송신기” 방식입니다.

마무리

미니스포럼 N5 Pro를 NAS로 운영할 때, WOL이 잡히면 운영 난이도가 확 내려갑니다.
필요할 때만 깨워서 쓰고 다시 끄는 패턴이 가능해지니까요.

핵심은 한 줄입니다.

ErP 끄고, 빠른 시작 끄고, ipTIME WOL로 외부에서도 깨우기.

게시물 [리뷰/팁] 미니스포럼 N5 Pro NAS 구축기: 윈도우 11에서 WOL 완벽 설정하기 (BIOS + Windows + ipTIME 외부 WOL까지)이 하우인포-IT·테크에 처음 등장했습니다.

오늘 미니스포럼 N5 Pro가 드디어 도착했습니다. ^^
그런데… 저는 첫날부터 한 번 크게 삽질을 시작합니다.
**SSD 128GB / 메모리 16GB가 ‘같이 왔는데 어디를 봐도 없더라구요 그런데 본체에 탑재 되어 있음 , OS가 설치되어 있을 줄 알고 전원을 넣었다가 부팅이 안 되는 상황을 겪었습니다. 이게 뭘까나 .
결국 제조사 안내와 MinisCloud OS Installation step(PDF) 문서를 참고해 OS를 새로 설치하고 나서야 정상 부팅에 성공했어요.

이 글은 저처럼 “처음 받자마자 바로 쓰려다 막히는” 분들을 위해, 언박싱 → SSD/메모리 장착 → OS 설치(재설치) → 첫 세팅까지 한 번에 정리한 실전 기록입니다.

1) 언박싱: 사진 몇장 올립니다.

2) 첫날 멘붕 포인트: “동봉 = 탑재 = OS 설치”가 아니었다

제가 실수한 흐름은 이랬습니다.

• SSD 128GB / RAM 16GB가 같이 왔음
• 당연히 본체에 장착돼 있고, OS도 설치돼 있을 줄 알고 전원 ON
• 결과: 부팅 불가(또는 OS 진입 불가)
• 해결: SSD/메모리 장착 후 MinisCloud OS를 새로 받아 설치

혹시 저처럼 “받자마자 부팅이 안 된다”면, 무조건 아래부터 확인하는 게 빠릅니다.

• SSD가 실제로 장착돼 있는지
• 메모리가 장착돼 있는지
• OS가 비어있거나 손상된 상태는 아닌지(재설치 필요)

3) SSD / 메모리 장착: OS 설치 전에 먼저 끝내야 할 작업

3-1. 작업 전 필수

• 전원 케이블 완전 분리
• 정전기 방지(금속 프레임 잠깐 만지기)
• 나사/부품 분실 주의

3-2. SSD 장착 체크(가장 흔한 실수)

• M.2 SSD는 규격이 여러 종류라, NVMe인지부터 확인하고 장착합니다.
• “예전에 쓰던 M.2”를 재활용하려다가 SATA 방식이라 인식이 안 되는 경우도 많아요.

3-3. 메모리 장착 체크

• 메모리 슬롯에 끝까지 밀어 넣고 “딱” 고정되는 느낌이 나야 합니다.
• 헐겁게 끼워지면 부팅 자체가 안 되거나, 전원만 들어오고 화면이 안 뜨는 경우가 생깁니다.

저는 첫날 “어? 왜 안 켜지지?”에서 시간을 많이 썼는데, 지금 생각하면 SSD/메모리 장착 여부를 먼저 확인했으면 30분 컷이었어요.

4) OS 설치(재설치) 준비물: 이거 없으면 시작이 안 됨

제가 실제로 사용한 “정석 루틴”은 이 준비물부터입니다.

• 다른 PC 1대(Windows면 가장 편함)
• USB 메모리(8GB 이상 권장)
• 모니터(HDMI), 키보드/마우스
• 유선 LAN(가능하면 권장)
• MinisCloud OS 설치 파일 + 설치 안내 PDF(Installation step)

5) MinisCloud OS 설치(재설치) 실전 루틴

아래 흐름은 **PDF 설치 가이드(Installation step)**를 참고해서, 제가 실제로 해결한 방식대로 “실수 안 나게” 정리한 절차입니다.

5-1. 설치 USB 만들기

1. MinisCloud OS 설치 파일을 내려받습니다.
2. 안내 문서에서 지정한 방식대로 부팅 USB를 생성합니다.
   • 여기서 실패가 많습니다. “파일을 USB에 복사”가 아니라 **부팅 가능한 형태로 ‘굽기/쓰기’**가 되어야 합니다.

자주 터지는 문제

• USB가 부팅으로 안 잡힘 → “USB 생성이 제대로 안 됨” 가능성이 큼
• USB 포트 변경/다른 USB로 재시도하면 해결되는 경우도 많습니다.

5-2. N5 Pro에 연결(설치 모드)

• USB(설치용) 연결
• HDMI로 모니터 연결
• 키보드/마우스 연결
• 유선 LAN 연결
• 전원 ON

5-3. 부팅 메뉴(또는 BIOS)에서 USB 부팅

• 전원을 켠 직후, 부트 메뉴 키를 눌러 USB를 선택합니다.
• 메뉴 진입이 안 되면 재부팅하면서 타이밍을 조금씩 조정합니다.

5-4. 설치 대상 디스크 선택(중요)

• 설치 화면에서 “대상 디스크”를 고르게 됩니다.
• 보통 OS는 **내장 SSD(128GB)**에 설치하는 흐름이 가장 단순합니다.

⚠️ 주의
이 단계에서 디스크 선택을 잘못하면, 데이터가 있는 드라이브를 포맷할 수 있습니다.
첫 설치는 ‘새 디스크만’ 꽂고 시작하는 게 마음 편합니다.

5-5. 설치 완료 → 재부팅 → USB 제거

• 설치가 끝나면 재부팅 후 USB를 뽑고 내장 SSD로 부팅되게 합니다.
• 여기서 USB를 꽂아둔 채로 두면 다시 설치 화면으로 들어가 “왜 또 설치 화면이지?”가 발생합니다.

6) 설치 후 첫 세팅: “당일에 끝내는 기본 안정화”

OS 설치가 끝났으면, 그 다음은 운영 안정화입니다. 저는 첫날에 아래만은 꼭 해둡니다.

6-1. 계정/보안

• 관리자 계정 비밀번호는 강하게 설정
• 가능하면 2단계 인증/접근제한 옵션도 함께 확인

6-2. 네트워크

• 유선 LAN으로 먼저 안정화
• 이후에 필요하면 고속 포트(5G/10G) 환경을 단계적으로 업그레이드

6-3. 스토리지 구성

• 단일 디스크로 시작할지, 미러/RAID로 갈지 결정
• “백업이 필요한 데이터”라면, 초기부터 이중화/백업 루틴을 설계하는 게 마음 편합니다.

6-4. 설치 위치/발열

• NAS는 24시간 도는 장비라, 통풍 확보가 중요합니다.
• 벽에 너무 붙이지 말고, 상단/후면 공기 흐름을 막지 않게 설치합니다.

7) 제가 느낀 N5 Pro 첫인상(짧은 후기)

• “NAS + 미니PC” 성격이 강해서, 단순 파일서버를 넘어서 도커/자동화/개발 쪽으로 확장하기 좋아 보였습니다.
• 다만 첫날은 “기대(탑재/설치 완료)” 때문에 삽질을 했고,
  이 경험 덕분에 오히려 설치 과정 전체를 내 손으로 정리해두게 되어 장기적으로는 더 든든해졌습니다.

8) 당일 체크리스트(복붙용)

• SSD 128GB가 본체에 실제 장착됐는지 확인
• 메모리 16GB가 정상 장착됐는지 확인
• 설치 USB 생성(부팅 가능 형태로 쓰기 완료)
• HDMI/키보드/마우스 연결 후 부팅
• 부트 메뉴/BIOS에서 USB 부팅 선택
• 설치 대상 디스크 선택 실수 방지(데이터 디스크 포맷 주의)
• 설치 완료 후 재부팅 + USB 제거
• 관리자 계정/보안 설정
• 스토리지 구성(단일/미러/RAID) 결정
• 통풍 확보/설치 위치 정리

9) FAQ

Q1. “받자마자 부팅이 안 돼요.” 제일 먼저 뭘 봐야 하나요?

A. SSD/메모리가 동봉만 되고 미장착인 경우가 있어요. 내부를 열어 실제로 장착되어 있는지가 1순위입니다.

Q2. OS가 설치된 줄 알았는데 비어있을 수도 있나요?

A. 네. 케이스에 따라 OS가 준비되어 있어도 손상/미탑재 상태일 수 있어, MinisCloud OS 재설치 루틴을 알아두면 가장 빨리 복구됩니다.

Q3. 설치 USB 만들었는데 USB로 부팅이 안 돼요.

A. 파일 복사가 아니라 **부팅 가능한 형태로 “쓰기/굽기”**가 되어야 합니다. USB를 바꾸거나 다른 포트로 재시도하면 해결되는 경우가 많습니다.

Q4. 디스크 여러 개 꽂아도 되나요?

A. 가능하지만 첫 설치는 새 디스크만으로 시작하는 편이 안전합니다. 설치 과정에서 디스크 선택을 잘못하면 포맷 사고가 날 수 있어요.

저처럼 삽질 하지 마시고 . 일단 중요한것은

os가 설치가 안되어 있고 미니스포럼 사이트에서 os를 받아서 싱글보드 이미지 굽듯이 구워서 다시 설치하고 부팅 그리고 같은 네트워크에서 동일 대역에서 접근해야 함 할때 . 인증등 있음 아래 참고

게시물 미니스포럼 N5 Pro 언박싱부터 OS 설치까지: 집 NAS 세팅 실전기이 하우인포-IT·테크에 처음 등장했습니다.

• “파이썬 설치해야 해?”
• “pip로 뭐 설치해야 해?”
• “실행했더니 검은 창만 뜨고 꺼지는데?”

그래서 결국 많이 선택하는 방법이 EXE로 패키징하는 겁니다.
이번 글은 제가 실제로 가장 많이 쓰는 도구인 PyInstaller 기준으로, “초보도 따라 할 수 있게” 정리했습니다.

1) EXE 만들기 전에 꼭 알아야 할 것

✅ EXE로 만들면 좋은 점

• 파이썬이 설치되지 않은 PC에서도 실행 가능(대부분의 경우)
• 배포/공유가 편해짐
• 파일 1개(또는 폴더 1개)로 정리 가능

⚠️ 현실적으로 생기는 문제

• 용량이 커짐(수십~수백 MB도 흔함)
• 백신 오탐(특히 새로 만든 exe)
• 경로 문제(파일 저장/설정 파일 위치)
• GUI(Tkinter 등)에서는 괜찮은데, 콘솔 출력은 안 보이기도 함

이걸 미리 알고 가면 삽질이 크게 줄어요.

2) 준비물: 파이썬/폴더 구조 추천

권장 폴더 구조 예시

my_app/
  main.py
  core/
  assets/
  data/
  requirements.txt

• assets/ : 이미지, 아이콘 등 리소스
• data/ : 설정 파일, 저장 파일(앱 실행 중 생성되는 데이터)
• requirements.txt : 의존성 목록

3) PyInstaller 설치

가장 먼저 가상환경을 추천합니다. (빌드가 깔끔해져요)

(선택) 가상환경 만들기

cd my_app
python -m venv .venv
.venv\Scripts\activate

PyInstaller 설치

python -m pip install --upgrade pip
pip install pyinstaller

설치 확인:

pyinstaller --version

4) 가장 기본 빌드: onefile로 EXE 만들기

콘솔 프로그램(터미널 창 필요)

pyinstaller --onefile main.py

GUI 프로그램(창만 띄우고 콘솔 숨김)

pyinstaller --onefile --noconsole main.py

빌드가 끝나면 보통 아래 폴더가 생깁니다.

• dist/ : 실제 배포 파일(exe)
• build/ : 빌드 캐시
• main.spec : 빌드 설정 파일

결과 EXE는 dist/main.exe 에서 확인합니다.

5) 아이콘 넣기(윈도우 exe 느낌 살리기)

아이콘은 .ico 파일이 필요합니다. (png 그대로는 안됨)

pyinstaller --onefile --noconsole --icon=assets/app.ico main.py

6) 이미지/설정파일 등 “외부 파일” 포함하기

여기서 많이 막힙니다.
파이썬에서는 상대경로로 잘 읽히는데, exe로 묶이면 경로가 달라져요.

6-1) 빌드 옵션으로 파일 포함

예: assets/ 폴더를 함께 포함

pyinstaller --onefile --noconsole ^
  --add-data "assets;assets" ^
  main.py

윈도우에서 --add-data "원본;대상" 형태로 세미콜론(;)을 사용합니다.

6-2) exe 환경에서 경로 처리(핵심)

파이썬 코드에서 “실행 위치”를 잡는 함수를 넣어두면 안정적입니다.

import os, sysdef resource_path(relative_path: str) -> str:
    # PyInstaller로 묶이면 _MEIPASS 경로에 리소스가 풀림
    base_path = getattr(sys, "_MEIPASS", os.path.dirname(os.path.abspath(__file__)))
    return os.path.join(base_path, relative_path)

사용 예:

icon_path = resource_path("assets/app.ico")

7) “exe 실행하면 저장이 안돼요/초기화돼요” 문제 해결

이 현상은 거의 대부분 저장 위치가 잘못 잡혀서 생깁니다.

• 개발 중: 프로젝트 폴더에 저장
• exe 실행: 사용자 PC의 다른 위치에서 실행 → 상대경로가 달라짐
• 또는 Program Files 아래라면 쓰기 권한 문제로 저장 실패

추천: 사용자 폴더(AppData) 아래에 저장 폴더 만들기

import osdef get_app_data_dir(app_name="MyApp"):
    base = os.getenv("APPDATA")  # C:\Users\...\AppData\Roaming
    path = os.path.join(base, app_name)
    os.makedirs(path, exist_ok=True)
    return path

저장 예:

cfg_path = os.path.join(get_app_data_dir("HStockGuard"), "config.json")

이렇게 하면 exe로 배포해도 설정/저장 데이터가 유지됩니다.

8) 자주 겪는 에러/해결 체크리스트

✅ 실행하자마자 창이 꺼짐

• 콘솔 모드로 빌드해서 에러 확인
  --noconsole 빼고 실행해보기

✅ 모듈 못 찾는다고 나옴

• 누락된 모듈을 hidden-import로 추가

pyinstaller --onefile --hidden-import=패키지명 main.py

✅ 백신이 위험하다고 막음

• 새 exe는 오탐이 흔함
• 코드서명까지는 현실적으로 어렵고, 최소한 배포 파일을 자주 바꾸지 않는 게 도움
• 가능하면 onedir 배포도 고려(오탐이 덜 나는 경우가 있음)

✅ 용량이 너무 큼

• 가상환경을 깨끗하게 유지
• 불필요한 패키지 제거
• --exclude-module 사용 고려(상황에 따라)

9) 배포 방식 추천: onefile vs onedir

onefile

• 장점: 파일 1개로 배포 끝
• 단점: 실행 시 임시폴더에 풀리는 과정 때문에 첫 실행이 느릴 수 있음

onedir

pyinstaller --noconsole main.py

• 장점: 실행 빠르고 문제 추적이 쉬움
• 단점: 폴더째로 배포해야 함

개인적으로는 처음엔 onedir로 안정화 → 마지막에 onefile로 마무리하는 경우가 많았습니다.

FAQ

Q1. PyInstaller 말고 다른 방법도 있나요?
A. 네. cx_Freeze, Nuitka 같은 대안도 있습니다. 다만 가장 대중적이고 자료가 많은 건 PyInstaller입니다.

Q2. 32비트/64비트는 어떻게 맞추나요?
A. 빌드에 사용하는 파이썬이 64비트면 보통 64비트 exe가 됩니다. 배포 대상 PC 환경과 맞추세요.

Q3. exe로 만들면 소스가 완전히 숨겨지나요?
A. 완전한 보안은 아닙니다. “배포 편의” 목적에 가깝다고 보는 게 현실적입니다.

부록) 그대로 복사해서 쓰는 샘플 코드(저장 유지 + 리소스 경로)

core/paths.py

import os
import sysdef resource_path(relative_path: str) -> str:
    """
    PyInstaller(onefile)에서 리소스 경로를 안전하게 가져온다.
    """
    base_path = getattr(sys, "_MEIPASS", os.path.dirname(os.path.abspath(__file__)))
    return os.path.join(base_path, relative_path)def appdata_dir(app_name: str = "MyApp") -> str:
    """
    AppData\Roaming 아래에 앱 폴더를 생성해 저장 경로로 사용한다.
    """
    base = os.getenv("APPDATA") or os.path.expanduser("~")
    path = os.path.join(base, app_name)
    os.makedirs(path, exist_ok=True)
    return path

core/config.py

import json
import os
from .paths import appdata_dirdef load_config(app_name: str = "MyApp", filename: str = "config.json") -> dict:
    path = os.path.join(appdata_dir(app_name), filename)
    if not os.path.exists(path):
        return {}
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)def save_config(cfg: dict, app_name: str = "MyApp", filename: str = "config.json") -> str:
    path = os.path.join(appdata_dir(app_name), filename)
    with open(path, "w", encoding="utf-8") as f:
        json.dump(cfg, f, ensure_ascii=False, indent=2)
    return path

main.py (테스트용)

from core.config import load_config, save_configAPP_NAME = "HowinfoPyExeDemo"def main():
    cfg = load_config(APP_NAME)
    run_count = int(cfg.get("run_count", 0)) + 1
    cfg["run_count"] = run_count    saved_path = save_config(cfg, APP_NAME)
    print(f"[OK] 실행 횟수: {run_count}")
    print(f"[OK] 설정 저장 위치: {saved_path}")if __name__ == "__main__":
    main()

빌드 명령어(윈도우)

pyinstaller --onefile main.py

GUI + 아이콘 + assets 포함 예시:

pyinstaller --onefile --noconsole ^
  --icon=assets/app.ico ^
  --add-data "assets;assets" ^
  main.py

게시물 파이썬 프로그램을 윈도우 EXE로 만드는 방법 (PyInstaller 실전 가이드)이 하우인포-IT·테크에 처음 등장했습니다.

오렌지파이5에서 **보유 종목(주식/ETF)**을 파일로 관리하고,

• 수익 최고점(peak) 대비 -X% 트레일링
• 매수가 대비 -Y% 손절
• 손절/트레일링 근접 경고
• 1시간 요약 / 15:35 요약 / 16:00 리포트
• 리스크 HIGH일 때만 30분→10분 자동 단축
• 다음날 자동 재감시(active=1 복구)
  를 시놀로지 Chat 웹훅으로 자동 알림해주는 파이썬 봇입니다.

※ 가격은 yfinance 기반이라 “지연 Close”로 동작합니다(실시간 아님).
실시간으로 바꾸려면 추후 키움 API 등 연동이 필요합니다.

1) 동작 개념(핵심 로직)

✅ 트레일링(수익 구간)

• 내 매수금액(평가금액 기준) 대비 최고점(peak)을 계속 갱신
• 기준선 = peak × (1 - trailing%)
• 현재가가 기준선 이하로 내려오면 매도 알림

✅ 가변 트레일링(수익이 커질수록 더 타이트)

예: base trailing이 10%인 종목이라면

• 수익 0~20%: 10%
• 수익 20~50%: 7% (10%×0.7)
• 수익 50% 이상: 5% (10%×0.5)

✅ 손절(매수가 기준)

• 손절선 = 매수금액 × (1 - stop_loss%)
• 현재가가 손절선 이하로 내려오면 손절 알림

✅ 근접 경고

• 트레일링 기준선까지 2% 이내로 접근하면 “근접 경고”
• 손절선까지 2% 이내로 접근하면 “손절 근접 경고”

✅ 리스크 레벨(LOW / MEDIUM / HIGH)

• Trigger(기준선 이하) / Near(근접) 종목 수
• 위험 노출 비중(Trigger+Near 종목 평가금액 합 / 전체 평가금액)
  을 기준으로 LOW/MEDIUM/HIGH 표시
  → 장중 요약, 16:00 리포트에 같이 출력

✅ 실행 주기 자동 변경(장중만)

• 평소 장중: 30분
• 리스크 HIGH: 10분(더 촘촘히 감시)
• 장외: 120분(불필요 호출 절약)

✅ 다음날 자동 재활성화

• 매도/손절 알림 후 active=0으로 자동 비활성화(옵션)
• 다음날 09:01에 자동으로 active=1로 복구(옵션)

2) 폴더 구성(그대로 만들기)

아래 3개 파일만 있으면 됩니다.

jusik_top10/
 ├─ main.py
 ├─ config.json
 ├─ positions.csv
 └─ state.json   (없으면 자동 생성됨, 처음엔 {} 권장)

3) 설치(오렌지파이5)

sudo apt update
sudo apt install -y python3-pip
python3 -m pip install --user requests yfinance

4) config.json (복붙용)

synology_chat_webhook_url만 본인 값으로 바꿔주세요.

{
  "synology_chat_webhook_url": "여기에_시놀로지챗_웹훅_URL_붙여넣기",  "default_trailing_pct": 0.10,
  "default_stop_loss_pct": 0.08,  "market_open": "09:00",
  "market_close": "15:30",  "startup_notify_enabled": true,  "near_alert_enabled": true,
  "near_alert_distance_pct": 2.0,
  "near_alert_cooldown_minutes": 60,  "stoploss_near_enabled": true,
  "stoploss_near_distance_pct": 2.0,
  "stoploss_near_cooldown_minutes": 180,  "auto_disable_on_alert": true,  "hourly_summary_enabled": true,
  "hourly_summary_interval_minutes": 60,  "daily_summary_time": "15:35",  "after_close_summary_enabled": true,
  "after_close_summary_time": "16:00",
  "after_close_include_inactive": false,  "adaptive_trailing_enabled": true,
  "adaptive_trailing_factors": [
    { "min_profit_pct": 0,  "factor": 1.0 },
    { "min_profit_pct": 20, "factor": 0.7 },
    { "min_profit_pct": 50, "factor": 0.5 }
  ],  "risk_high_near_count": 3,
  "risk_high_near_exposure_pct": 30,  "adaptive_interval_enabled": true,
  "interval_minutes_market": 30,
  "interval_minutes_high_risk": 10,
  "interval_minutes_off_market": 120,  "daily_reactivate_enabled": true,
  "daily_reactivate_time": "09:01"
}

5) positions.csv (복붙용)

• market: KS(코스피), KQ(코스닥)
• trailing_pct: 0.10 = 10%
• stop_loss_pct: 0.08 = -8%
• active: 1(감시), 0(감시중지)

code,name,market,qty,buy_price,trailing_pct,stop_loss_pct,active
005930,삼성전자,KS,10,70000,0.10,0.08,1
069500,KODEX 200,KS,20,35000,0.08,0.07,1

6) state.json 초기화(권장)

처음 적용할 때 state가 꼬였으면 초기화가 안전합니다.

echo "{}" > state.json

7) main.py (전체 소스 — 그대로 복붙)

아래 코드를 main.py로 저장하세요.

# (아래 전체 코드 그대로 복붙)
"""
Orange Pi 5 (Ubuntu/ARM) 주식/ETF 트레일링 스탑 알림 시스템 (yfinance 기반, 지연 Close OK)[핵심 기능]
- positions.csv 관리: 종목/수량/매수가/trailing_pct/stop_loss_pct/active
- state.json 유지: peak_value, last_alerted_peak, 근접 경고 시각, 요약 발송 기록 등
- Synology Chat Incoming Webhook으로 알림 전송[장중(09:00~15:30) 기능]
1) 손절(매수가 기준) 알림: entry*(1-stop_loss_pct) 이하
2) 손절 근접 경고: 손절선까지 +X% 남으면(0% 이하면 손절)
3) 트레일링(수익구간) 알림: peak*(1-eff_trailing) 이하
4) 트레일링 근접 경고: 기준선까지 +X% 남으면
5) 1시간 요약(장중): 총 수익률 + 종목별 요약 + 리스크 레벨[장마감 이후]
- 15:35 일일 요약(TOP3/WORST3)
- 16:00 리포트(섹션 분리: TRIGGER/NEAR/SAFE + 손절 정보 + 리스크)[추가 보강]
- 가변 트레일링(Adaptive Trailing): base_trailing_pct × factor(수익구간별)
- 리스크 HIGH일 때 장중 주기 자동 단축(예: 30→10분)
- 매도/손절 알림 후 auto_disable_on_alert=true면 active=0 자동 변경
- 다음날 지정 시간에 active=0 → active=1 자동 재활성화(옵션)
- state.json 깨짐 자동복구 + 원자저장
- positions.csv 원자저장
- 시작 1회 안내 메시지[주의]
- yfinance는 지연 Close 기반(실시간 아님)
"""import os
import json
import time
import csv
import tempfile
from dataclasses import dataclass
from datetime import datetime, time as dtimeimport requests
import yfinance as yfBASE = os.path.dirname(os.path.abspath(__file__))
CONFIG_PATH = os.path.join(BASE, "config.json")
POSITIONS_PATH = os.path.join(BASE, "positions.csv")
STATE_PATH = os.path.join(BASE, "state.json")def log(step: str, msg: str = "", level: str = "INFO"):
    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    if msg:
        print(f"[{now}] [{level}] [{step}] {msg}")
    else:
        print(f"[{now}] [{level}] [{step}]")def fmt_money(x) -> str:
    return f"{x:,.0f}"def parse_hhmm(s: str) -> dtime:
    hh, mm = s.split(":")
    return dtime(hour=int(hh), minute=int(mm))def is_market_open(now: datetime, open_t: dtime, close_t: dtime) -> bool:
    t = now.time()
    return open_t <= t <= close_tdef load_json_safe(path, default):
    if not os.path.exists(path):
        return default
    try:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
        bak = f"{path}.broken_{ts}"
        try:
            os.replace(path, bak)
        except:
            try:
                import shutil
                shutil.copy2(path, bak)
            except:
                pass
        print(f"[WARN] JSON이 깨져 자동 복구했습니다. 백업: {bak} / 오류: {e}")
        return defaultdef save_json_atomic(path, data):
    tmp_dir = os.path.dirname(path) or "."
    fd, tmp_path = tempfile.mkstemp(prefix="state_", suffix=".json", dir=tmp_dir)
    os.close(fd)
    try:
        with open(tmp_path, "w", encoding="utf-8") as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
        os.replace(tmp_path, path)
    finally:
        if os.path.exists(tmp_path):
            try:
                os.remove(tmp_path)
            except:
                passdef parse_float_optional(x):
    if x is None:
        return None
    s = str(x).strip()
    if s == "":
        return None
    return float(s)def parse_int_optional(x, default=1):
    if x is None:
        return default
    s = str(x).strip()
    if s == "":
        return default
    try:
        return int(float(s))
    except:
        return default@dataclass
class Position:
    code: str
    name: str
    market: str
    qty: float
    buy_price: float
    trailing_pct: float
    stop_loss_pct: float
    active: int    @property
    def ticker(self) -> str:
        return f"{self.code}.{self.market.upper()}"def load_positions_csv(path, default_trailing_pct: float, default_stop_loss_pct: float) -> list[Position]:
    if not os.path.exists(path):
        raise RuntimeError(f"positions.csv가 없습니다: {path}")    positions = []
    with open(path, "r", encoding="utf-8-sig") as f:
        reader = csv.DictReader(f)
        required = {"code", "qty", "buy_price"}
        if not required.issubset(set(reader.fieldnames or [])):
            raise RuntimeError(f"positions.csv 컬럼이 필요합니다: {sorted(required)}")        for row in reader:
            code = row["code"].strip()
            name = (row.get("name") or code).strip()
            market = (row.get("market") or "KS").strip().upper()
            if market not in ("KS", "KQ"):
                raise RuntimeError(f"{code} market 값 오류: {market} (KS/KQ만 허용)")            qty = float(row["qty"])
            buy_price = float(row["buy_price"])            trailing_pct = parse_float_optional(row.get("trailing_pct"))
            if trailing_pct is None:
                trailing_pct = default_trailing_pct
            if not (0 < trailing_pct < 1):
                raise RuntimeError(f"{code} trailing_pct 비정상: {trailing_pct}")            stop_loss_pct = parse_float_optional(row.get("stop_loss_pct"))
            if stop_loss_pct is None:
                stop_loss_pct = default_stop_loss_pct
            if not (0 <= stop_loss_pct < 1):
                raise RuntimeError(f"{code} stop_loss_pct 비정상: {stop_loss_pct}")            active = parse_int_optional(row.get("active"), default=1)
            active = 1 if active != 0 else 0            positions.append(Position(code, name, market, qty, buy_price, trailing_pct, stop_loss_pct, active))
    return positionsdef save_positions_csv_atomic(path, positions: list[Position]):
    fieldnames = ["code", "name", "market", "qty", "buy_price", "trailing_pct", "stop_loss_pct", "active"]
    tmp_dir = os.path.dirname(path) or "."
    fd, tmp_path = tempfile.mkstemp(prefix="positions_", suffix=".csv", dir=tmp_dir)
    os.close(fd)
    try:
        with open(tmp_path, "w", encoding="utf-8-sig", newline="") as f:
            w = csv.DictWriter(f, fieldnames=fieldnames)
            w.writeheader()
            for p in positions:
                w.writerow({
                    "code": p.code, "name": p.name, "market": p.market,
                    "qty": p.qty, "buy_price": p.buy_price,
                    "trailing_pct": p.trailing_pct, "stop_loss_pct": p.stop_loss_pct,
                    "active": p.active
                })
        os.replace(tmp_path, path)
    finally:
        if os.path.exists(tmp_path):
            try: os.remove(tmp_path)
            except: passdef send_synology_chat(webhook_url: str, text: str):
    payload_json = json.dumps({"text": text}, ensure_ascii=False)
    r = requests.post(webhook_url, data={"payload": payload_json}, timeout=10)
    r.raise_for_status()def get_last_price_yf(ticker: str) -> float:
    hist = yf.Ticker(ticker).history(period="7d")
    if hist is None or hist.empty:
        raise RuntimeError(f"가격 데이터 비어있음: {ticker}")
    return float(hist["Close"].iloc[-1])def get_adaptive_factor(cfg: dict, peak_profit_pct: float) -> float:
    if not bool(cfg.get("adaptive_trailing_enabled", True)):
        return 1.0
    tiers = cfg.get("adaptive_trailing_factors", [])
    if not isinstance(tiers, list) or len(tiers) == 0:
        return 1.0    valid = []
    for t in tiers:
        try:
            m = float(t.get("min_profit_pct", 0))
            f = float(t.get("factor", 1.0))
            if f > 0:
                valid.append((m, f))
        except:
            pass    if not valid:
        return 1.0    valid.sort(key=lambda x: x[0])
    chosen = valid[0][1]
    for m, f in valid:
        if peak_profit_pct >= m:
            chosen = f
        else:
            break
    return chosendef effective_trailing_pct(cfg: dict, base_trailing_pct: float, entry_value: float, peak_value: float) -> float:
    if entry_value <= 0:
        return base_trailing_pct
    peak_profit_pct = (peak_value - entry_value) / entry_value * 100.0
    factor = get_adaptive_factor(cfg, peak_profit_pct)
    eff = base_trailing_pct * factor
    eff = max(eff, 0.01)
    eff = min(eff, base_trailing_pct)
    return effdef cleanup_state(state: dict, active_codes: set[str]):
    for k in list(state.keys()):
        if k in ("_summary", "_hourly_summary", "_startup", "_after_close_summary", "_reactivate"):
            continue
        if k not in active_codes:
            del state[k]def should_send_daily_summary(state: dict, now: datetime, summary_time: dtime) -> bool:
    if now.time() < summary_time:
        return False
    today = now.strftime("%Y-%m-%d")
    s = state.setdefault("_summary", {})
    return s.get("last_date") != todaydef should_send_hourly_summary_market_only(state: dict, now: datetime, interval_minutes: int, market_open: bool) -> bool:
    if not market_open:
        return False
    hourly = state.setdefault("_hourly_summary", {})
    last_str = hourly.get("last_sent")
    if not last_str:
        return True
    last_dt = datetime.strptime(last_str, "%Y-%m-%d %H:%M:%S")
    diff_min = (now - last_dt).total_seconds() / 60.0
    return diff_min >= interval_minutesdef should_send_after_close_summary(state: dict, now: datetime, summary_time: dtime) -> bool:
    if now.time() < summary_time:
        return False
    today = now.strftime("%Y-%m-%d")
    s = state.setdefault("_after_close_summary", {})
    return s.get("last_date") != todaydef should_send_startup_notify(state: dict) -> bool:
    st = state.setdefault("_startup", {})
    return not bool(st.get("sent", False))def mark_startup_notify_sent(state: dict):
    st = state.setdefault("_startup", {})
    st["sent"] = True
    st["sent_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")def should_reactivate_today(state: dict, now: datetime, hhmm: str) -> bool:
    t = parse_hhmm(hhmm)
    if now.time() < t:
        return False
    today = now.strftime("%Y-%m-%d")
    s = state.setdefault("_reactivate", {})
    return s.get("last_date") != todaydef reactivate_all_positions(positions_all: list[Position], state: dict) -> bool:
    changed = False
    for p in positions_all:
        if p.active == 0:
            p.active = 1
            changed = True
    if changed:
        state.setdefault("_reactivate", {})["last_date"] = datetime.now().strftime("%Y-%m-%d")
    return changeddef calc_risk_level(detail_list: list[dict], total_current_active: float, cfg: dict, near_dist: float) -> dict:
    trigger = [d for d in detail_list if d.get("active") == 1 and d.get("to_stop", 999) <= 0]
    near = [d for d in detail_list if d.get("active") == 1 and 0 < d.get("to_stop", 999) <= near_dist]    trigger_cnt = len(trigger)
    near_cnt = len(near)    risk_exposure = sum(float(d.get("cur", 0.0)) for d in (trigger + near))
    exposure_pct = (risk_exposure / total_current_active * 100.0) if total_current_active > 0 else 0.0    high_near_cnt = int(cfg.get("risk_high_near_count", 3))
    high_exposure_pct = float(cfg.get("risk_high_near_exposure_pct", 30))    if trigger_cnt > 0 or near_cnt >= high_near_cnt or exposure_pct >= high_exposure_pct:
        level = "HIGH"
    elif near_cnt > 0:
        level = "MEDIUM"
    else:
        level = "LOW"    return {
        "level": level,
        "trigger_cnt": trigger_cnt,
        "near_cnt": near_cnt,
        "risk_exposure": risk_exposure,
        "exposure_pct": exposure_pct
    }def top_worst_lines(rows, n=3):
    rows_desc = sorted(rows, key=lambda r: r["rate_now"], reverse=True)[:n]
    rows_asc = sorted(rows, key=lambda r: r["rate_now"], reverse=False)[:n]    def line(r):
        sign = "+" if r["profit_now"] >= 0 else ""
        return f"- {r['name']}({r['code']}): {r['rate_now']:+.2f}% ({sign}{fmt_money(r['profit_now'])}원)"    return [line(r) for r in rows_desc], [line(r) for r in rows_asc]def run_once(cfg: dict, positions_all: list[Position], state: dict):
    now = datetime.now()
    now_str = now.strftime("%Y-%m-%d %H:%M:%S")    webhook_url = cfg["synology_chat_webhook_url"]    market_open_t = parse_hhmm(cfg.get("market_open", "09:00"))
    market_close_t = parse_hhmm(cfg.get("market_close", "15:30"))
    daily_summary_t = parse_hhmm(cfg.get("daily_summary_time", "15:35"))    hourly_enabled = bool(cfg.get("hourly_summary_enabled", True))
    hourly_interval = int(cfg.get("hourly_summary_interval_minutes", 60))    auto_disable = bool(cfg.get("auto_disable_on_alert", True))    near_enabled = bool(cfg.get("near_alert_enabled", True))
    near_dist = float(cfg.get("near_alert_distance_pct", 2.0))
    near_cooldown = int(cfg.get("near_alert_cooldown_minutes", 60))    sl_near_enabled = bool(cfg.get("stoploss_near_enabled", True))
    sl_near_dist = float(cfg.get("stoploss_near_distance_pct", 2.0))
    sl_near_cooldown = int(cfg.get("stoploss_near_cooldown_minutes", 180))    after_close_enabled = bool(cfg.get("after_close_summary_enabled", True))
    after_close_time = parse_hhmm(cfg.get("after_close_summary_time", "16:00"))
    include_inactive = bool(cfg.get("after_close_include_inactive", False))    positions_active = [p for p in positions_all if p.active == 1]
    active_codes = {p.code for p in positions_active}
    cleanup_state(state, active_codes)    market_open = is_market_open(now, market_open_t, market_close_t)
    log("MARKET", f"장중={market_open}")    price_targets = positions_all if include_inactive else positions_active
    price_cache: dict[str, float] = {}    log("PRICE", f"조회 대상={len(price_targets)}")
    for p in price_targets:
        if p.code in price_cache:
            continue
        try:
            price_cache[p.code] = get_last_price_yf(p.ticker)
        except Exception as e:
            log("PRICE", f"FAIL {p.name}({p.code}) {e}", level="WARN")    positions_ok = [p for p in positions_active if p.code in price_cache]
    if not positions_ok:
        return False, "LOW", market_open    total_entry = total_current = total_peak = 0.0
    rows = []    for p in positions_ok:
        entry_value = p.qty * p.buy_price
        current_value = p.qty * price_cache[p.code]
        s = state.setdefault(p.code, {})        peak_value = float(s.get("peak_value", entry_value))
        if current_value > peak_value:
            peak_value = current_value
        s["peak_value"] = peak_value        profit_now = current_value - entry_value
        rate_now = (profit_now / entry_value * 100.0) if entry_value else 0.0        total_entry += entry_value
        total_current += current_value
        total_peak += peak_value        rows.append({"code": p.code, "name": p.name, "profit_now": profit_now, "rate_now": rate_now})    total_profit_now = total_current - total_entry
    total_rate_now = (total_profit_now / total_entry * 100.0) if total_entry else 0.0    changed_positions = False
    if market_open:
        pos_map = {p.code: p for p in positions_all}        for p in positions_ok:
            entry_value = p.qty * p.buy_price
            current_value = p.qty * price_cache[p.code]
            s = state.setdefault(p.code, {})
            peak_value = float(s.get("peak_value", entry_value))            # 손절 근접 + 손절 트리거
            if p.stop_loss_pct > 0:
                stop_loss_value = entry_value * (1 - p.stop_loss_pct)
                to_stoploss = (current_value - stop_loss_value) / stop_loss_value * 100.0 if stop_loss_value > 0 else None                if sl_near_enabled and to_stoploss is not None and (0 < to_stoploss <= sl_near_dist):
                    ns = state.setdefault(p.code, {})
                    last_sl_near = ns.get("last_stoploss_near_alert_at")
                    can_send = True
                    if last_sl_near:
                        last_dt = datetime.strptime(last_sl_near, "%Y-%m-%d %H:%M:%S")
                        can_send = (now - last_dt).total_seconds() >= sl_near_cooldown * 60
                    if can_send:
                        msg = (
                            f"[손절 근접 경고/매수가 -{int(p.stop_loss_pct*100)}%]\n"
                            f"- {p.name}({p.code})\n"
                            f"- 손절선까지 거리: {to_stoploss:+.2f}% (0% 이하이면 손절)\n"
                            f"- 최근가(지연 Close): {fmt_money(price_cache[p.code])}원\n"
                            f"- 손절선: {fmt_money(stop_loss_value)}원\n"
                            f"- 평가금액: {fmt_money(current_value)}원\n"
                            f"- 시각: {now_str}"
                        )
                        send_synology_chat(webhook_url, msg)
                        ns["last_stoploss_near_alert_at"] = now_str                stop_loss_triggered = current_value <= stop_loss_value
                last_sl = s.get("last_stop_loss_alert_at")
                already_today = bool(last_sl and last_sl[:10] == now_str[:10])
                if stop_loss_triggered and not already_today:
                    msg = (
                        f"[손절 알림/매수가 -{int(p.stop_loss_pct*100)}%]\n"
                        f"- {p.name}({p.code})\n"
                        f"- 최근가(지연 Close): {fmt_money(price_cache[p.code])}원\n"
                        f"- 평가금액: {fmt_money(current_value)}원\n"
                        f"- 손절선: {fmt_money(stop_loss_value)}원\n"
                        f"- 매수금액: {fmt_money(entry_value)}원\n"
                        f"- 시각: {now_str}"
                    )
                    send_synology_chat(webhook_url, msg)
                    s["last_stop_loss_alert_at"] = now_str
                    if auto_disable and pos_map[p.code].active != 0:
                        pos_map[p.code].active = 0
                        changed_positions = True            # 트레일링 근접 + 트리거
            last_alerted_peak = float(s.get("last_alerted_peak", 0))
            if peak_value > entry_value:
                eff_trailing = effective_trailing_pct(cfg, p.trailing_pct, entry_value, peak_value)
                stop_value = peak_value * (1 - eff_trailing)
                to_stop = (current_value - stop_value) / stop_value * 100.0
                drop_from_peak = (peak_value - current_value) / peak_value * 100.0
                triggered = current_value <= stop_value                if near_enabled and (0 < to_stop <= near_dist):
                    ns = state.setdefault(p.code, {})
                    last_near = ns.get("last_near_alert_at")
                    can_send = True
                    if last_near:
                        last_dt = datetime.strptime(last_near, "%Y-%m-%d %H:%M:%S")
                        can_send = (now - last_dt).total_seconds() >= near_cooldown * 60
                    if can_send:
                        msg = (
                            f"[근접 경고/트레일링 {int(eff_trailing*100)}%]\n"
                            f"- {p.name}({p.code})\n"
                            f"- 기준선까지 거리: {to_stop:+.2f}% (0% 이하이면 트리거)\n"
                            f"- 피크 대비 하락률: {drop_from_peak:.2f}%\n"
                            f"- 최근가(지연 Close): {fmt_money(price_cache[p.code])}원\n"
                            f"- 시각: {now_str}"
                        )
                        send_synology_chat(webhook_url, msg)
                        ns["last_near_alert_at"] = now_str                if triggered and last_alerted_peak < peak_value:
                    msg = (
                        f"[매도 알림/트레일링 {int(eff_trailing*100)}%]\n"
                        f"- {p.name}({p.code})\n"
                        f"- 기준선까지 거리: {to_stop:+.2f}% (트리거)\n"
                        f"- 피크 대비 하락률: {drop_from_peak:.2f}%\n"
                        f"- 최근가(지연 Close): {fmt_money(price_cache[p.code])}원\n"
                        f"- 시각: {now_str}"
                    )
                    send_synology_chat(webhook_url, msg)
                    s["last_alerted_peak"] = peak_value
                    if auto_disable and pos_map[p.code].active != 0:
                        pos_map[p.code].active = 0
                        changed_positions = True    # 리스크/리포트용 상세 리스트
    positions_for_report = positions_all if include_inactive else positions_active
    detail_list = []
    for p in positions_for_report:
        if p.code not in price_cache:
            continue
        entry_value = p.qty * p.buy_price
        current_value = p.qty * price_cache[p.code]
        s = state.get(p.code, {})
        peak_value = float(s.get("peak_value", entry_value))
        eff_trailing = effective_trailing_pct(cfg, p.trailing_pct, entry_value, peak_value) if peak_value > entry_value else p.trailing_pct
        stop_value = peak_value * (1 - eff_trailing) if peak_value else 0.0
        to_stop = (current_value - stop_value) / stop_value * 100.0 if stop_value else 0.0        stop_loss_value = entry_value * (1 - p.stop_loss_pct) if p.stop_loss_pct > 0 else 0.0
        to_stoploss = (current_value - stop_loss_value) / stop_loss_value * 100.0 if stop_loss_value > 0 else None        profit_now = current_value - entry_value
        rate_now = (profit_now / entry_value * 100.0) if entry_value else 0.0        detail_list.append({
            "name": p.name, "code": p.code, "active": p.active,
            "cur": current_value, "entry": entry_value,
            "profit": profit_now, "rate": rate_now,
            "peak": peak_value, "eff_trailing": eff_trailing,
            "stop": stop_value, "to_stop": to_stop,
            "stop_loss_pct": p.stop_loss_pct, "stop_loss_value": stop_loss_value, "to_stoploss": to_stoploss
        })    risk = calc_risk_level(detail_list, total_current, cfg, near_dist)    # 장중 1시간 요약
    if bool(cfg.get("hourly_summary_enabled", True)):
        if should_send_hourly_summary_market_only(state, now, int(cfg.get("hourly_summary_interval_minutes", 60)), market_open):
            lines = []
            for r in rows:
                sign = "+" if r["profit_now"] >= 0 else ""
                lines.append(f"- {r['name']}({r['code']}): {r['rate_now']:+.2f}% ({sign}{fmt_money(r['profit_now'])}원)")            risk_box = (
                f"[리스크 레벨: {risk['level']}]\n"
                f"- Trigger: {risk['trigger_cnt']} / Near: {risk['near_cnt']}\n"
                f"- 위험노출: {fmt_money(risk['risk_exposure'])}원 ({risk['exposure_pct']:.1f}%)\n"
            )            msg = (
                f"[1시간 포트폴리오 요약]\n"
                f"- 총 손익: {fmt_money(total_profit_now)}원\n"
                f"- 총 수익률: {total_rate_now:+.2f}%\n\n"
                + risk_box + "\n"
                + "\n".join(lines) +
                f"\n\n- 시각: {now_str}"
            )
            send_synology_chat(webhook_url, msg)
            state.setdefault("_hourly_summary", {})["last_sent"] = now_str    # 15:35 일일 요약
    if should_send_daily_summary(state, now, daily_summary_t):
        total_profit_peak = total_peak - total_entry
        total_rate_peak = (total_profit_peak / total_entry * 100.0) if total_entry else 0.0
        top3, worst3 = top_worst_lines(rows, n=3)        msg = (
            f"[포트폴리오 일일 요약]\n"
            f"- 총 매수금액: {fmt_money(total_entry)}원\n"
            f"- 총 평가금액(현재): {fmt_money(total_current)}원\n"
            f"- 총 손익(현재): {fmt_money(total_profit_now)}원 ({total_rate_now:+.2f}%)\n"
            f"- 총 최고평가(피크): {fmt_money(total_peak)}원\n"
            f"- 총 손익(피크): {fmt_money(total_profit_peak)}원 ({total_rate_peak:+.2f}%)\n"
            f"\n[손익률 TOP3]\n" + "\n".join(top3) +
            f"\n\n[손익률 WORST3]\n" + "\n".join(worst3) +
            f"\n\n- 시각: {now_str}"
        )
        send_synology_chat(webhook_url, msg)
        state.setdefault("_summary", {})["last_date"] = now.strftime("%Y-%m-%d")    # 16:00 리포트(섹션 분리)
    if bool(cfg.get("after_close_summary_enabled", True)) and should_send_after_close_summary(state, now, after_close_time):
        trigger = [d for d in detail_list if d["active"] == 1 and d["to_stop"] <= 0]
        near = [d for d in detail_list if d["active"] == 1 and 0 < d["to_stop"] <= near_dist]
        safe = [d for d in detail_list if d["active"] == 1 and d["to_stop"] > near_dist]        def line(d):
            a = "A1" if d["active"] == 1 else "A0"
            sl_part = ""
            if d["stop_loss_pct"] > 0 and d["to_stoploss"] is not None:
                sl_part = f" / to_SL={d['to_stoploss']:+.2f}%(-{int(d['stop_loss_pct']*100)}%)"
            sign = "+" if d["profit"] >= 0 else ""
            return (
                f"- {d['name']}({d['code']})[{a}] to_stop={d['to_stop']:+.2f}%{sl_part}\n"
                f"  cur={fmt_money(d['cur'])} stop={fmt_money(d['stop'])} eff_trailing={int(d['eff_trailing']*100)}% "
                f"pnl={sign}{fmt_money(d['profit'])}원 ({d['rate']:+.2f}%)"
            )        risk_box = (
            f"[리스크 레벨: {risk['level']}]\n"
            f"- Trigger: {risk['trigger_cnt']} / Near: {risk['near_cnt']}\n"
            f"- 위험노출: {fmt_money(risk['risk_exposure'])}원 ({risk['exposure_pct']:.1f}%)\n"
        )        msg = (
            f"[16:00 리포트/기준선+손절+리스크]\n"
            f"- 총 손익(active=1): {fmt_money(total_profit_now)}원\n"
            f"- 총 수익률(active=1): {total_rate_now:+.2f}%\n"
            f"- 설명: to_stop=+X%는 트레일 기준선까지 남은 비율(0% 이하 트리거)\n"
            f"- 설명: to_SL=+X%는 손절선까지 남은 비율(0% 이하 손절)\n\n"
            + risk_box + "\n"
            + "🚨 TRIGGER\n" + ("\n".join(line(d) for d in trigger) if trigger else "- 없음") + "\n\n"
            + f"⚠️ NEAR (<= {near_dist:.1f}%)\n" + ("\n".join(line(d) for d in near) if near else "- 없음") + "\n\n"
            + "✅ SAFE\n" + ("\n".join(line(d) for d in safe) if safe else "- 없음") +
            f"\n\n- 시각: {now_str}"
        )
        send_synology_chat(webhook_url, msg)
        state.setdefault("_after_close_summary", {})["last_date"] = now.strftime("%Y-%m-%d")    if changed_positions:
        save_positions_csv_atomic(POSITIONS_PATH, positions_all)    return changed_positions, risk["level"], market_opendef main():
    cfg = load_json_safe(CONFIG_PATH, {})
    if not cfg:
        raise RuntimeError("config.json이 없습니다.")    default_trailing_pct = float(cfg.get("default_trailing_pct", 0.10))
    default_stop_loss_pct = float(cfg.get("default_stop_loss_pct", 0.08))    state = load_json_safe(STATE_PATH, {})    if bool(cfg.get("startup_notify_enabled", True)) and should_send_startup_notify(state):
        try:
            positions_all = load_positions_csv(POSITIONS_PATH, default_trailing_pct, default_stop_loss_pct)
            active_positions = [p for p in positions_all if p.active == 1]
            lines = [
                f"- {p.name}({p.code}.{p.market}) qty={p.qty:g} buy={fmt_money(p.buy_price)} "
                f"trail={int(p.trailing_pct*100)}% sl={int(p.stop_loss_pct*100)}%"
                for p in active_positions
            ]
            msg = "[주식 알림봇 시작]\n" + "\n".join(lines) + f"\n- 시각: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
            send_synology_chat(cfg["synology_chat_webhook_url"], msg)
            mark_startup_notify_sent(state)
            save_json_atomic(STATE_PATH, state)
        except Exception as e:
            log("STARTUP", f"시작 안내 실패: {e}", level="WARN")    while True:
        now = datetime.now()
        try:
            positions_all = load_positions_csv(POSITIONS_PATH, default_trailing_pct, default_stop_loss_pct)            if bool(cfg.get("daily_reactivate_enabled", True)):
                if should_reactivate_today(state, now, cfg.get("daily_reactivate_time", "09:01")):
                    if reactivate_all_positions(positions_all, state):
                        save_positions_csv_atomic(POSITIONS_PATH, positions_all)
                        save_json_atomic(STATE_PATH, state)            changed, risk_level, market_open = run_once(cfg, positions_all, state)
            save_json_atomic(STATE_PATH, state)            sleep_min = int(cfg.get("interval_minutes_market", 30))
            if bool(cfg.get("adaptive_interval_enabled", True)):
                mkt_min = int(cfg.get("interval_minutes_market", sleep_min))
                high_min = int(cfg.get("interval_minutes_high_risk", 10))
                off_min = int(cfg.get("interval_minutes_off_market", 120))
                sleep_min = (high_min if risk_level == "HIGH" else mkt_min) if market_open else off_min            log("SLEEP", f"{sleep_min}분 후 재실행 (risk={risk_level}, market_open={market_open})")
            time.sleep(sleep_min * 60)        except Exception as e:
            log("ERROR", f"루프 오류: {e}", level="ERROR")
            time.sleep(120)if __name__ == "__main__":
    main()

8) 실행(백그라운드)

cd ~/python/jusik_top10
nohup python3.9 main.py > jusik.log 2>&1 &
tail -f jusik.log

9) 운영 팁

• positions.csv에서 active=0으로 수동 비활성화 가능
• 손절/트레일링 트리거 후 auto_disable_on_alert=true면 자동으로 active=0
• 다음날 09:01에 자동으로 active=1 복구 (옵션)

10) 트러블슈팅

✅ config.json이 없습니다

• main.py와 같은 폴더에 config.json이 있는지 확인

ls -al

✅ state.json JSONDecodeError(Extra data)

• 파일이 깨진 것 → {}로 초기화

cp state.json state.json.bak
echo "{}" > state.json

✅ 알림이 안 오면

• webhook URL 오타/토큰 확인
• 방화벽/SSL 문제 여부 확인
• logs 확인

tail -n 200 jusik.log

게시물 Orange Pi 5로 “주식/ETF 트레일링 스탑 + 손절 + 리스크 레벨” 알림봇 만들기 (Synology Chat 웹훅, 10~30분 자동 주기)_버전 두번째 full 소스이 하우인포-IT·테크에 처음 등장했습니다.

주식을 하다 보면 이런 생각이 듭니다.

“최고 수익에서 10%만 빠지면 정리하고 싶은데…
내가 계속 보고 있을 수는 없잖아?”

그래서 오렌지파이5에 상시 감시용 트레일링 알림 시스템을 만들었습니다.

✔ 일반주식 + ETF 모두 가능
✔ 종목별로 트레일링 % 다르게 설정
✔ 장중에만 매도 알림
✔ 장마감 후 하루 1번 요약
✔ 매도 알림 발생 시 자동 감시 해제

이 글에서는 실제 운영 가능한 코드 구조를 정리합니다.

🧠 시스템 구조

positions.csv   → 보유 종목 관리
config.json     → 시스템 설정
state.json      → 종목별 최고 수익(peak) 저장
main.py         → 전체 로직 실행

📊 핵심 로직 (트레일링 스탑)

1️⃣ 기본 계산

entry_value   = 매수수량 × 매수가
current_value = 매수수량 × 현재가
peak_value    = max(기존 peak_value, current_value)

2️⃣ 트레일링 기준선

stop_value = peak_value × (1 - trailing_pct)

3️⃣ 매도 알림 조건

수익 구간에서만 적용
current_value <= stop_value 이면 알림

✔ 계속 오르면 peak가 올라감
✔ 기준선도 같이 올라감
✔ 최고점 대비 n% 하락 시 알림

🗂 1️⃣ 보유 종목 파일 (positions.csv)

code,name,market,qty,buy_price,trailing_pct,active
005930,삼성전자,KS,10,70000,0.10,1
069500,KODEX 200,KS,20,35000,0.08,1
035420,NAVER,KS,3,200000,0.12,1

✔ 매도 알림 발생 시 active=0 자동 변경

⚙ 2️⃣ 설정 파일 (config.json)

{
  "interval_minutes": 30,
  "default_trailing_pct": 0.10,
  "synology_chat_webhook_url": "웹훅URL",  "market_open": "09:00",
  "market_close": "15:30",  "daily_summary_time": "15:35",  "auto_disable_on_alert": true
}

🖥 3️⃣ 오렌지파이5 설치

python3 -m pip install --upgrade pip
python3 -m pip install yfinance requests

✔ ARM 환경에서 가장 안정적
✔ FinanceDataReader 대신 yfinance 사용

🧾 4️⃣ 전체 실행 코드 (주석 상세 버전)

아래는 핵심 구조가 잘 보이도록 정리한 “설명형 소스”입니다.

"""
OrangePi5 트레일링 스탑 알림 시스템
- 주식 + ETF 지원
- 종목별 trailing_pct 적용
- 장중만 매도 알림
- 하루 1회 요약
- 매도 발생 시 active=0 자동 변경
"""import os
import json
import time
import csv
from datetime import datetime, timedelta, time as dtime
import requests
import yfinance as yf# -------------------------
# 기본 경로 설정
# -------------------------
BASE = os.path.dirname(os.path.abspath(__file__))
CONFIG_PATH = os.path.join(BASE, "config.json")
POSITIONS_PATH = os.path.join(BASE, "positions.csv")
STATE_PATH = os.path.join(BASE, "state.json")# -------------------------
# 유틸 함수
# -------------------------
def log(msg):
    print(f"[{datetime.now()}] {msg}")def fmt(x):
    return f"{x:,.0f}"def parse_hhmm(s):
    h, m = s.split(":")
    return dtime(int(h), int(m))# -------------------------
# Synology Chat 알림
# -------------------------
def send_chat(url, text):
    payload = json.dumps({"text": text}, ensure_ascii=False)
    requests.post(url, data={"payload": payload})# -------------------------
# 가격 조회 (yfinance)
# -------------------------
def get_price(code, market):
    ticker = f"{code}.{market}"
    hist = yf.Ticker(ticker).history(period="7d")
    return float(hist["Close"].iloc[-1])# -------------------------
# 메인 실행
# -------------------------
def main():
    config = json.load(open(CONFIG_PATH))
    state = json.load(open(STATE_PATH)) if os.path.exists(STATE_PATH) else {}    open_t = parse_hhmm(config["market_open"])
    close_t = parse_hhmm(config["market_close"])
    summary_t = parse_hhmm(config["daily_summary_time"])    while True:
        now = datetime.now()        # positions 읽기
        positions = list(csv.DictReader(open(POSITIONS_PATH, encoding="utf-8-sig")))
        positions = [p for p in positions if p.get("active","1") == "1"]        total_entry = total_current = total_peak = 0
        rows = []        for p in positions:
            code = p["code"]
            market = p.get("market","KS")
            qty = float(p["qty"])
            buy = float(p["buy_price"])
            trailing = float(p.get("trailing_pct") or config["default_trailing_pct"])            price = get_price(code, market)            entry = qty * buy
            current = qty * price            peak = state.get(code, {}).get("peak", entry)
            peak = max(peak, current)            state.setdefault(code, {})["peak"] = peak            # 트레일링 조건
            if open_t <= now.time() <= close_t:
                stop = peak * (1 - trailing)
                if current <= stop:
                    send_chat(config["synology_chat_webhook_url"],
                              f"[매도 알림] {p['name']} 최고대비 {int(trailing*100)}% 하락")
                    if config["auto_disable_on_alert"]:
                        p["active"] = "0"            total_entry += entry
            total_current += current
            total_peak += peak            rows.append((p["name"], (current-entry)/entry*100))        # 하루 1회 요약
        if now.time() >= summary_t:
            if state.get("summary_date") != now.strftime("%Y-%m-%d"):
                profit = total_current - total_entry
                send_chat(config["synology_chat_webhook_url"],
                          f"[일일 요약] 총 손익 {fmt(profit)}원")
                state["summary_date"] = now.strftime("%Y-%m-%d")        json.dump(state, open(STATE_PATH,"w"), indent=2)        log("루프 완료. 다음 실행 대기...")
        time.sleep(config["interval_minutes"]*60)if __name__ == "__main__":
    main()

📈 실행 중 로그 예시

[2026-02-25 10:00] 가격 조회 시작
[2026-02-25 10:00] 삼성전자 peak 갱신
[2026-02-25 10:00] 트레일링 체크 완료
[2026-02-25 10:00] 루프 완료. 다음 실행 대기...

📌 운영하면서 느낀 점

• 지연 시세 기반이라 실시간 체결가 기반은 아님
• 그러나 구조 테스트 및 자동 감시 시스템에는 충분
• 실시간으로 확장하려면 가격 조회 부분만 API로 교체하면 됨

🚀 다음 확장 방향

• 증권사 API 연동
• 텔레그램/카카오톡 알림 추가
• Streamlit 대시보드 추가
• 매수 전략 자동화

🧩 결론

이 시스템은

✔ 오렌지파이5 같은 저전력 장비에 적합
✔ 구조가 단순해서 유지보수 쉬움
✔ 나중에 실시간 API로 확장 가능

입니다.

게시물 오렌지파이5로 주식·ETF 트레일링 스탑 알림 시스템 만들기이 하우인포-IT·테크에 처음 등장했습니다.