DevOps Archives - 어제와 내일의 나 그 사이의 이야기

Linux Development Tools Install

lycos7560 — Mon, 16 Feb 2026 22:31:03 +0000

Development Tools (개발 도구 모음) ?

Development Tools (개발 도구 모음) ?

Linux에서 소프트웨어를 개발하고 컴파일하는 데 필요한 도구들의 패키지입니다.

예를 들어 “VMware Tools”처럼 C/C++ 소스 코드로 작성된 프로그램을 설치할 때 반드시 필요합니다.

설치 명령

rocky linux

dnf groupinstall "Development Tools" -y

// vm-tool 설치 (Rocky Linux 공식 저장소에서 설치, ISO 방식이 아님)
sudo dnf install open-vm-tools open-vm-tools-desktop -y

부분	의미	주의
`sudo`	관리자 권한	필수!
`dnf`	Rocky Linux 패키지 매니저	Ubuntu는 `apt`
`groupinstall`	패키지 그룹 설치	`install`과 다름
`"Development Tools"`	그룹 이름	따옴표 필수
`-y`	Yes 자동 응답	사용자 입력 생략

설치 시간 및 용량

예상 시간: 3-5분
설치 크기: ~1GB
필요 디스크: ~2GB

설치 결과

20260217 설치 결과는 Rocky Linux 버전 및 시간에 따라 다를 수 있습니다.

--------------

Installed:
  annobin-docs-12.99-1.el10.noarch                 annobin-plugin-gcc-12.99-1.el10.x86_64               asciidoc-10.2.0-12.el10.noarch                   autoconf-2.71-13.el10.noarch                                   
  automake-1.16.5-20.el10.noarch                   bison-3.8.2-9.el10.x86_64                            boost-atomic-1.83.0-5.el10.x86_64                boost-filesystem-1.83.0-5.el10.x86_64                          
  boost-regex-1.83.0-5.el10.x86_64                 boost-system-1.83.0-5.el10.x86_64                    boost-thread-1.83.0-5.el10.x86_64                byacc-2.0.20230521-7.el10.x86_64                               
  cmake-filesystem-3.30.5-3.el10_0.x86_64          cpp-14.3.1-2.1.el10.x86_64                           debugedit-5.1-8.el10.x86_64                      diffstat-1.66-3.el10.x86_64                                    
  docbook-dtds-1.0-92.el10.noarch                  docbook-style-xsl-1.79.2-30.el10.noarch              dwz-0.16-1.el10.x86_64                           dyninst-13.0.0-1.el10.x86_64                                   
  efi-srpm-macros-6-7.el10.noarch                  efivar-libs-39-3.el10.x86_64                         elfutils-0.193-1.el10.rocky.0.1.x86_64           elfutils-debuginfod-client-devel-0.193-1.el10.rocky.0.1.x86_64 
  elfutils-devel-0.193-1.el10.rocky.0.1.x86_64     elfutils-libelf-devel-0.193-1.el10.rocky.0.1.x86_64  flex-2.6.4-19.el10.x86_64                        fonts-srpm-macros-1:2.0.5-18.el10.noarch                       
  forge-srpm-macros-0.4.0-6.el10.noarch            gcc-14.3.1-2.1.el10.x86_64                           gcc-c++-14.3.1-2.1.el10.x86_64                   gcc-plugin-annobin-14.3.1-2.1.el10.x86_64                      
  gdb-16.3-2.el10.x86_64                           gdb-headless-16.3-2.el10.x86_64                      gettext-common-devel-0.22.5-6.el10.noarch        gettext-devel-0.22.5-6.el10.x86_64                             
  git-2.47.3-1.el10.x86_64                         git-core-2.47.3-1.el10.x86_64                        git-core-doc-2.47.3-1.el10.noarch                glibc-devel-2.39-58.el10_1.7.x86_64                            
  go-srpm-macros-3.6.0-4.el10.noarch               graphviz-9.0.0-15.el10.x86_64                        intltool-0.51.0-29.el10.noarch                   javapackages-filesystem-6.4.0-1.el10.noarch                    
  jna-5.14.0-7.el10.x86_64                         kernel-devel-6.12.0-124.35.1.el10_1.x86_64           kernel-headers-6.12.0-124.35.1.el10_1.x86_64     kernel-srpm-macros-1.0-26.el10.noarch                          
  libipt-2.1-5.el10.x86_64                         libstdc++-devel-14.3.1-2.1.el10.x86_64               libtool-2.4.7-13.el10.x86_64                     libxcrypt-devel-4.4.36-10.el10.x86_64                          
  libzstd-devel-1.5.5-9.el10.x86_64                ltrace-0.7.91-52.el10.x86_64                         lua-srpm-macros-1-15.el10.noarch                 m4-1.4.19-11.el10.x86_64                                       
  make-1:4.4.1-9.el10.x86_64                       mokutil-2:0.7.2-1.el10.x86_64                        nss-tools-3.112.0-4.el10_0.x86_64                ocaml-srpm-macros-10-4.el10.noarch                             
  openblas-srpm-macros-2-19.el10.noarch            openssl-devel-1:3.5.1-7.el10_1.x86_64                package-notes-srpm-macros-0.5-13.el10.noarch     patch-2.7.6-26.el10.x86_64                                     
  patchutils-0.4.2-15.el10.x86_64                  perl-Clone-0.46-10.el10.x86_64                       perl-Compress-Raw-Bzip2-2.212-512.el10.x86_64    perl-Compress-Raw-Zlib-2.212-513.el10_1.x86_64                 
  perl-Data-Dump-1.25-13.el10.noarch               perl-Digest-HMAC-1.04-12.el10.noarch                 perl-Digest-SHA-1:6.04-512.el10.x86_64           perl-Encode-Locale-1.05-31.el10.noarch                         
  perl-Error-1:0.17029-18.el10.noarch              perl-Fedora-VSP-0.001-36.el10.noarch                 perl-File-Compare-1.100.800-512.2.el10_0.noarch  perl-File-Copy-2.41-512.2.el10_0.noarch                        
  perl-File-Listing-6.16-5.el10.noarch             perl-Git-2.47.3-1.el10.noarch                        perl-HTML-Parser-3.82-3.el10.x86_64              perl-HTML-Tagset-3.20-59.el10.noarch                           
  perl-HTTP-Cookies-6.11-5.el10.noarch             perl-HTTP-Date-6.06-6.el10.noarch                    perl-HTTP-Message-6.45-5.el10.noarch             perl-HTTP-Negotiate-6.01-40.el10.noarch                        
  perl-I18N-Langinfo-0.24-512.2.el10_0.x86_64      perl-IO-Compress-2.212-512.el10.noarch               perl-IO-HTML-1.004-14.el10.noarch                perl-LWP-MediaTypes-6.04-19.el10.noarch                        
  perl-Module-Load-1:0.36-511.el10.noarch          perl-NTLM-1.09-41.el10.noarch                        perl-Net-HTTP-6.23-6.el10.noarch                 perl-TermReadKey-2.38-24.el10.x86_64                           
  perl-Thread-Queue-3.14-511.el10.noarch           perl-TimeDate-1:2.33-16.el10.noarch                  perl-Try-Tiny-0.31-12.el10.noarch                perl-WWW-RobotRules-6.02-41.el10.noarch                        
  perl-XML-Parser-2.47-6.el10.x86_64               perl-generators-1.16-7.el10.noarch                   perl-lib-0.65-512.2.el10_0.x86_64                perl-libwww-perl-6.76-3.el10.noarch                            
  perl-macros-4:5.40.2-512.2.el10_0.noarch         perl-srpm-macros-1-57.el10.noarch                    perl-subs-1.04-512.2.el10_0.noarch               perl-threads-1:2.40-511.el10.x86_64                            
  perl-threads-shared-1.69-511.el10.x86_64         perl-version-8:0.99.32-4.el10.x86_64                 pesign-116-6.el10.x86_64                         pyproject-srpm-macros-1.16.2-1.el10.noarch                     
  python-srpm-macros-3.12-10.el10.noarch           qt6-srpm-macros-6.9.1-1.el10.noarch                  redhat-rpm-config-293-1.el10.rocky.0.2.noarch    rpm-build-4.19.1.1-20.el10.x86_64                              
  rpm-sign-4.19.1.1-20.el10.x86_64                 rust-toolset-srpm-macros-1.88.0-1.el10.noarch        sgml-common-0.6.3-65.el10.noarch                 source-highlight-3.1.9-25.el10.x86_64                          
  systemd-rpm-macros-257-13.el10.rocky.0.1.noarch  systemtap-5.3-3b.el10.x86_64                         systemtap-client-5.3-3b.el10.x86_64              systemtap-devel-5.3-3b.el10.x86_64                             
  systemtap-runtime-5.3-3b.el10.x86_64             tbb-2021.11.0-7.el10.x86_64                          valgrind-1:3.25.1-3.el10.x86_64                  valgrind-devel-1:3.25.1-3.el10.x86_64                          
  valgrind-docs-1:3.25.1-3.el10.x86_64             valgrind-gdb-1:3.25.1-3.el10.x86_64                  valgrind-scripts-1:3.25.1-3.el10.x86_64          xz-devel-1:5.6.2-4.el10_0.x86_64                               
  zlib-ng-compat-devel-2.2.3-3.el10_1.x86_64       zstd-1.5.5-9.el10.x86_64                            

Complete!

주요 설치 파일 (C/C++ 기준)

컴파일러 (Compiler)

소스 코드(.c, .cpp) → 기계어 실행파일로 변환

gcc-14.3.1           → C 언어 컴파일러
gcc-c++-14.3.1       → C++ 언어 컴파일러

빌드 도구 (Build Tools)

컴파일러 옵션 자동 설정 / 복잡한 빌드 과정 자동화 / 어떤 파일을 먼저 컴파일할지 관리 등…

make-4.4.1           → 자동 빌드 관리
autoconf-2.71        → 자동 설정 생성
automake-1.16.5      → Makefile 자동 생성

커널 개발 패키지 (Kernel Development)

역할: 커널과 상호작용하는 모듈 작성 가능

kernel-devel-6.12.0-124.35.1
kernel-headers-6.12.0-124.35.1
-----------------------------------------------
설치 명령어
sudo dnf install kernel-devel kernel-headers -y

라이브러리 개발 패키지 (Library Development)

역할: 컴파일된 코드를 실행 가능 파일로 연결 (링킹)

glibc-devel-2.39           → C 표준 라이브러리
libstdc++-devel-14.3.1     → C++ 표준 라이브러리
-----------------------------------------------
모든 C/C++ 프로그램의 기본 함수 제공
printf(), malloc() 등의 함수 구현

추가 개발 도구

Git: 소스 코드 변경 이력 관리, GDB: 프로그램 실행 중 오류 추적, libtool: 공유 라이브러리(.so) 빌드

git-2.47.3           → 소스 코드 버전 관리
gdb-16.3             → 프로그램 디버거
libtool-2.4.7        → 라이브러리 빌드 도구

참고 및 주의사항

groupinstall vs install

#  잘못된 방법 (의존성 부족 가능)
sudo dnf install gcc

#  올바른 방법 (모든 관련 도구 자동 설치)
sudo dnf groupinstall "Development Tools" -y

설치 확인

# 컴파일러 확인
gcc --version

# Make 확인
make --version

# 커널 헤더 확인
ls /usr/src/kernels/

오류 발생 시

네트워크 오류:

sudo dnf clean all
sudo dnf groupinstall "Development Tools" -y

의존성 충돌:

sudo dnf groupinstall "Development Tools" --allowerasing -y

The post Linux Development Tools Install appeared first on 어제와 내일의 나 그 사이의 이야기.

MySQL 데이터베이스 & 테이블 용량 확인

lycos7560 — Wed, 04 Feb 2026 20:16:04 +0000

1. 모든 데이터베이스별 총 용량 확인
2. 특정 데이터베이스 내의 테이블별 용량 상세 확인
3. 전체 서버의 총 합계 용량 확인
4. 참고

1. 모든 데이터베이스별 총 용량 확인

현재 서버에 있는 모든 DB의 크기를 한눈에 비교하고 싶을 때 사용합니다.

용량이 큰 순서대로 정렬되어 출력됩니다.

SELECT 
    table_schema AS 'Database Name',
    ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS 'Size (MB)',
    ROUND(SUM(data_free) / 1024 / 1024, 2) AS 'Free Space (MB)'
FROM 
    information_schema.tables
GROUP BY 
    table_schema
ORDER BY 
    (SUM(data_length + index_length)) DESC;

2. 특정 데이터베이스 내의 테이블별 용량 상세 확인

“어떤 테이블이 용량을 다 잡아먹고 있지?”라는 궁금증이 생겼을 때 사용합니다.

데이터 크기와 인덱스 크기를 구분해서 보여줍니다.

데이터 크기와 인덱스 크기를 구분

SELECT 
    table_name AS 'Table Name',
    table_rows AS 'Total Rows',
    ROUND(data_length / 1024 / 1024, 2) AS 'Data Size (MB)',
    ROUND(index_length / 1024 / 1024, 2) AS 'Index Size (MB)',
    ROUND((data_length + index_length) / 1024 / 1024, 2) AS 'Total Size (MB)'
FROM 
    information_schema.tables
WHERE 
    table_schema = '데이터베이스명' -- 여기에 DB 이름 입력
ORDER BY 
    (data_length + index_length) DESC;

3. 전체 서버의 총 합계 용량 확인

서버 전체에서 MySQL이 사용하는 총 디스크 용량만 깔끔하게 보고 싶을 때 유용합니다.

SELECT 
    ROUND(SUM(data_length + index_length) / 1024 / 1024 / 1024, 2) AS 'Total Global Size (GB)'
FROM 
    information_schema.tables;

4. 참고

data_length: 실제 데이터가 들어있는 물리적 크기입니다.
index_length: 인덱스(색인)가 차지하는 크기입니다. 데이터는 적은데 인덱스가 너무 크면 최적화(OPTIMIZE TABLE)를 고려해야 합니다.
data_free: DELETE 등으로 삭제된 행이 차지하던 ‘비어있는 공간’입니다. 이 값이 너무 크면 디스크 공간 낭비가 심하다는 뜻입니다.

The post MySQL 데이터베이스 & 테이블 용량 확인 appeared first on 어제와 내일의 나 그 사이의 이야기.

Apache Virtual Host Guide (Apache 가상 호스트 설정)

lycos7560 — Tue, 25 Nov 2025 14:56:56 +0000

기본 설정 확인
가상호스트 생성
다양한 설정 예제
SSL/HTTPS 설정
가상호스트 관리
문제 해결
보안 강화
성능 최적화
디렉토리 구조
유용한 명령어 모음
문제 상황별 체크리스트

기본 설정 확인

Apache 상태 및 설정 검증

# Apache 서비스 상태 확인
sudo systemctl status apache2

# 설정 파일 문법 검사
sudo apache2ctl configtest

# 활성화된 가상호스트 목록 확인
sudo apache2ctl -S

# Apache 버전 확인
apache2 -v

# 로드된 모듈 확인
apache2ctl -M

필수 모듈 활성화

# 프록시 및 SSL 관련 모듈 활성화
sudo a2enmod proxy
sudo a2enmod proxy_http
sudo a2enmod ssl
sudo a2enmod rewrite
sudo a2enmod headers

# 변경사항 적용
sudo systemctl restart apache2

가상호스트 생성

1. 설정 파일 생성

# 새 가상호스트 설정 파일 생성
sudo vim /etc/apache2/sites-available/testdomain.conf

2. 기본 HTTP 가상호스트


    ServerName testdomain.com
    ServerAlias www.testdomain.com
    ServerAdmin admin@testdomain.com
    
    DocumentRoot /var/www/testdomain
    
    
        Options -Indexes +FollowSymLinks
        AllowOverride All
        Require all granted
    
    
    ErrorLog ${APACHE_LOG_DIR}/testdomain_error.log
    CustomLog ${APACHE_LOG_DIR}/testdomain_access.log combined

3. HTTP → HTTPS 리다이렉트


    ServerName testdomain.com
    ServerAlias www.testdomain.com
    
    # 모든 HTTP 요청을 HTTPS로 리다이렉트
    RewriteEngine On
    RewriteCond %{HTTPS} off
    RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [R=301,L]
    
    ErrorLog ${APACHE_LOG_DIR}/testdomain_http_error.log
    CustomLog ${APACHE_LOG_DIR}/testdomain_http_access.log combined

4. HTTPS 가상호스트 (정적 파일)


    ServerName testdomain.com
    ServerAlias www.testdomain.com
    ServerAdmin admin@testdomain.com
    
    DocumentRoot /var/www/testdomain
    
    
        Options -Indexes +FollowSymLinks
        AllowOverride All
        Require all granted
    
    
    # SSL 설정
    SSLEngine on
    Include /etc/letsencrypt/options-ssl-apache.conf
    SSLCertificateFile /etc/letsencrypt/live/testdomain.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/testdomain.com/privkey.pem
    
    # 보안 헤더
    Header always set Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
    Header always set X-Content-Type-Options nosniff
    Header always set X-Frame-Options SAMEORIGIN
    Header always set X-XSS-Protection "1; mode=block"
    
    ErrorLog ${APACHE_LOG_DIR}/testdomain_https_error.log
    CustomLog ${APACHE_LOG_DIR}/testdomain_https_access.log combined

다양한 설정 예제

리버스 프록시


    ServerName api.testdomain.com
    
    # SSL 설정
    SSLEngine on
    SSLProxyEngine on
    Include /etc/letsencrypt/options-ssl-apache.conf
    SSLCertificateFile /etc/letsencrypt/live/api.testdomain.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/api.testdomain.com/privkey.pem
    
    # 프록시 설정
    ProxyPreserveHost On
    ProxyPass / http://localhost:3000/
    ProxyPassReverse / http://localhost:3000/
    
    # 프록시 헤더 설정
    RequestHeader set X-Forwarded-Proto "https"
    RequestHeader set X-Forwarded-Port "443"
    ProxyAddHeaders On
    
    # 타임아웃 설정
    ProxyTimeout 300
    
    # 요청 크기 제한 해제
    LimitRequestBody 0
    LimitRequestLine 65536
    LimitRequestFieldSize 65536
    
    ErrorLog ${APACHE_LOG_DIR}/api_error.log
    CustomLog ${APACHE_LOG_DIR}/api_access.log combined

WebSocket 프록시


    ServerName ws.testdomain.com
    
    SSLEngine on
    SSLProxyEngine on
    Include /etc/letsencrypt/options-ssl-apache.conf
    SSLCertificateFile /etc/letsencrypt/live/ws.testdomain.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/ws.testdomain.com/privkey.pem
    
    # WebSocket 지원을 위한 프록시 설정
    ProxyPreserveHost On
    RewriteEngine On
    RewriteCond %{HTTP:Upgrade} =websocket [NC]
    RewriteRule /(.*)           ws://localhost:8080/$1 [P,L]
    RewriteCond %{HTTP:Upgrade} !=websocket [NC]
    RewriteRule /(.*)           http://localhost:8080/$1 [P,L]
    
    ProxyPassReverse / http://localhost:8080/
    
    ErrorLog ${APACHE_LOG_DIR}/ws_error.log
    CustomLog ${APACHE_LOG_DIR}/ws_access.log combined

여러 백엔드로 로드 밸런싱

sudo a2enmod proxy_balancer
sudo a2enmod lbmethod_byrequests


    BalancerMember http://localhost:3001
    BalancerMember http://localhost:3002
    BalancerMember http://localhost:3003
    ProxySet lbmethod=byrequests



    ServerName testdomain.com
    
    SSLEngine on
    Include /etc/letsencrypt/options-ssl-apache.conf
    SSLCertificateFile /etc/letsencrypt/live/testdomain.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/testdomain.com/privkey.pem
    
    ProxyPreserveHost On
    ProxyPass / balancer://mycluster/
    ProxyPassReverse / balancer://mycluster/
    
    ErrorLog ${APACHE_LOG_DIR}/testdomain_error.log
    CustomLog ${APACHE_LOG_DIR}/testdomain_access.log combined

경로별 다른 백엔드 라우팅


    ServerName testdomain.com
    
    SSLEngine on
    Include /etc/letsencrypt/options-ssl-apache.conf
    SSLCertificateFile /etc/letsencrypt/live/testdomain.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/testdomain.com/privkey.pem
    
    # API 요청은 백엔드 서버로
    ProxyPass /api http://localhost:8000/api
    ProxyPassReverse /api http://localhost:8000/api
    
    # 정적 파일은 직접 제공
    DocumentRoot /var/www/testdomain
    
        Require all granted
    
    
    ErrorLog ${APACHE_LOG_DIR}/testdomain_error.log
    CustomLog ${APACHE_LOG_DIR}/testdomain_access.log combined

특정 IP만 접근 허용


    ServerName admin.testdomain.com
    
    SSLEngine on
    Include /etc/letsencrypt/options-ssl-apache.conf
    SSLCertificateFile /etc/letsencrypt/live/admin.testdomain.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/admin.testdomain.com/privkey.pem
    
    DocumentRoot /var/www/admin
    
    
        # 특정 IP만 허용
        Require ip 192.168.1.0/24
        Require ip 10.0.0.5
    
    
    ErrorLog ${APACHE_LOG_DIR}/admin_error.log
    CustomLog ${APACHE_LOG_DIR}/admin_access.log combined

SSL/HTTPS 설정

Certbot으로 SSL 인증서 발급

# 자동 설정 (권장)
sudo certbot --apache -d testdomain.com -d www.testdomain.com

# 인증서만 발급 (수동 설정)
sudo certbot certonly --standalone -d testdomain.com -d www.testdomain.com

# 와일드카드 인증서 발급
sudo certbot certonly --manual --preferred-challenges dns -d testdomain.com -d *.testdomain.com

# 인증서 갱신 테스트
sudo certbot renew --dry-run

# 인증서 강제 갱신
sudo certbot renew --force-renewal

# 인증서 자동 갱신 크론잡 설정
sudo crontab -e
# 매일 새벽 2시에 갱신 확인
0 2 * * * certbot renew --quiet

SSL 설정 최적화

# /etc/letsencrypt/options-ssl-apache.conf 참고
# 또는 직접 설정

SSLEngine on
SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
SSLCipherSuite ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384
SSLHonorCipherOrder off
SSLSessionTickets off

# OCSP Stapling 활성화
SSLUseStapling on
SSLStaplingCache "shmcb:logs/stapling-cache(150000)"

가상호스트 관리

활성화/비활성화

# 가상호스트 활성화
sudo a2ensite testdomain.conf

# 가상호스트 비활성화
sudo a2dissite testdomain.conf

# 기본 사이트 비활성화
sudo a2dissite 000-default.conf

# 설정 적용 (다운타임 없음)
sudo systemctl reload apache2

# 설정 재시작 (다운타임 발생)
sudo systemctl restart apache2

모듈 관리

# 모듈 활성화
sudo a2enmod 모듈명

# 모듈 비활성화
sudo a2dismod 모듈명

# 자주 사용하는 모듈들
sudo a2enmod rewrite      # URL 재작성
sudo a2enmod headers      # HTTP 헤더 조작
sudo a2enmod proxy        # 프록시 기능
sudo a2enmod proxy_http   # HTTP 프록시
sudo a2enmod proxy_wstunnel  # WebSocket 프록시
sudo a2enmod ssl          # SSL/TLS
sudo a2enmod deflate      # 압축
sudo a2enmod expires      # 캐시 제어

문제 해결

로그 확인

# 실시간 에러 로그 모니터링
sudo tail -f /var/log/apache2/error.log

# 실시간 액세스 로그 모니터링
sudo tail -f /var/log/apache2/access.log

# 특정 가상호스트 로그
sudo tail -f /var/log/apache2/testdomain_error.log

# 마지막 100줄 확인
sudo tail -100 /var/log/apache2/error.log

# 특정 키워드로 검색
sudo grep "testdomain" /var/log/apache2/*.log

# 에러만 필터링
sudo grep "error" /var/log/apache2/error.log

# 최근 에러 (systemd)
sudo journalctl -u apache2 -n 50

연결 테스트

# HTTP 응답 헤더 확인
curl -I http://testdomain.com/

# HTTPS 응답 헤더 확인
curl -I https://testdomain.com/

# 상세 디버깅 정보
curl -v https://testdomain.com/

# POST 요청 테스트
curl -X POST https://testdomain.com/api/endpoint \
  -H "Content-Type: application/json" \
  -d '{"key":"value"}'

# SSL 인증서 정보 확인
openssl s_client -connect testdomain.com:443 -servername testdomain.com < /dev/null

# 백엔드 서비스 테스트
curl -v http://localhost:3000/

포트 및 프로세스 확인

# 특정 포트 사용 확인
sudo netstat -tlnp | grep :80
sudo netstat -tlnp | grep :443
sudo netstat -tlnp | grep :3000

# 또는 ss 명령어 사용 (더 빠름)
sudo ss -tlnp | grep :80

# Apache 프로세스 확인
ps aux | grep apache2

# 열린 파일 확인
sudo lsof -i :80
sudo lsof -i :443

일반적인 문제 해결

포트 충돌 문제 체크

Apache + Nginx 동시 사용 시 자주 발생
특히 Certbot –apache 사용 시 충돌할 수 있음.

sudo ss -tlnp | grep :80
sudo ss -tlnp | grep :443

// 만약 Nginx가 잡고 있다면
sudo systemctl stop nginx
sudo systemctl disable nginx

403 Forbidden 오류

# Directory 권한 확인

    Require all granted
    # 또는
    Options +Indexes


# 파일 시스템 권한 확인
sudo chmod -R 755 /var/www/testdomain
sudo chown -R www-data:www-data /var/www/testdomain

500 Internal Server Error

# 설정 문법 오류 확인
sudo apache2ctl configtest

# .htaccess 문제 확인
sudo tail -50 /var/log/apache2/error.log

# SELinux 확인 (CentOS/RHEL)
sudo setenforce 0  # 임시 비활성화

SSL 인증서 오류

# 인증서 파일 존재 확인
ls -la /etc/letsencrypt/live/testdomain.com/

# 인증서 유효기간 확인
sudo certbot certificates

# 인증서 갱신
sudo certbot renew

# SSL 인증서 권한 변경 주의
# SSLCertificateFile: file '/etc/letsencrypt/live/.../fullchain.pem' does not exist or is empty // 원인은 보통 인증서 폴더 권한 문제

sudo chmod 755 /etc/letsencrypt/live
sudo chmod 644 /etc/letsencrypt/live/DOMAIN/fullchain.pem
sudo chmod 600 /etc/letsencrypt/live/DOMAIN/privkey.pem

프록시 오류 (502 Bad Gateway)

# 백엔드 서비스 작동 확인
curl http://localhost:3000/

# SELinux 설정 (CentOS/RHEL)
sudo setsebool -P httpd_can_network_connect 1

# 프록시 타임아웃 늘리기
ProxyTimeout 600

Proxy 헤더 관련 ForwardedHeaders 추가

ASP.NET Core, Node.js, Django 모두 HTTPS 프록시 환경에서 필수

RequestHeader set X-Forwarded-For %{REMOTE_ADDR}s
RequestHeader set X-Forwarded-Proto https
RequestHeader set X-Forwarded-Host %{HTTP_HOST}s

# (예시) ASP.NET Core
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
    ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});

보안 강화

보안 헤더 설정


    ServerName testdomain.com
    
    # ... SSL 설정 ...
    
    # HSTS (HTTP Strict Transport Security)
    Header always set Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
    
    # XSS 방지
    Header always set X-XSS-Protection "1; mode=block"
    
    # MIME 타입 스니핑 방지
    Header always set X-Content-Type-Options "nosniff"
    
    # 클릭재킹 방지
    Header always set X-Frame-Options "SAMEORIGIN"
    
    # Referrer 정책
    Header always set Referrer-Policy "strict-origin-when-cross-origin"
    
    # CSP (Content Security Policy)
    Header always set Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';"
    
    # 서버 정보 숨기기
    ServerTokens Prod
    ServerSignature Off

접근 제어

# IP 기반 접근 제어

    # 특정 IP만 허용
    Require ip 192.168.1.0/24
    Require ip 10.0.0.5
    
    # 또는 특정 IP 차단
    Require all granted
    Require not ip 192.168.1.100


# HTTP Basic 인증

    AuthType Basic
    AuthName "Restricted Area"
    AuthUserFile /etc/apache2/.htpasswd
    Require valid-user

.htpasswd 파일 생성

# htpasswd 파일 생성 (첫 사용자)
sudo htpasswd -c /etc/apache2/.htpasswd username

# 추가 사용자 등록 (-c 옵션 제거)
sudo htpasswd /etc/apache2/.htpasswd username2

Rate Limiting (mod_ratelimit)


    SetOutputFilter RATE_LIMIT
    SetEnv rate-limit 400
    SetEnv rate-initial-burst 100

성능 최적화

캐싱 설정


    ServerName testdomain.com
    
    # ... 기본 설정 ...
    
    # 정적 파일 캐싱
    
        ExpiresActive On
        
        # 이미지
        ExpiresByType image/jpg "access plus 1 year"
        ExpiresByType image/jpeg "access plus 1 year"
        ExpiresByType image/gif "access plus 1 year"
        ExpiresByType image/png "access plus 1 year"
        ExpiresByType image/webp "access plus 1 year"
        ExpiresByType image/svg+xml "access plus 1 year"
        
        # CSS/JS
        ExpiresByType text/css "access plus 1 month"
        ExpiresByType application/javascript "access plus 1 month"
        
        # 폰트
        ExpiresByType font/woff2 "access plus 1 year"
        ExpiresByType font/woff "access plus 1 year"
        
        # HTML
        ExpiresByType text/html "access plus 1 hour"
    
    
    # Cache-Control 헤더
    
        Header set Cache-Control "max-age=31536000, public"

Gzip & Brotli 압축


    # 압축 활성화
    AddOutputFilterByType DEFLATE text/html text/plain text/xml text/css
    AddOutputFilterByType DEFLATE application/javascript application/json
    AddOutputFilterByType DEFLATE application/xml application/xhtml+xml
    AddOutputFilterByType DEFLATE image/svg+xml
    
    # 이미지는 압축 제외 (이미 압축됨)
    SetEnvIfNoCase Request_URI \.(?:gif|jpe?g|png|webp)$ no-gzip



sudo apt install libapache2-mod-brotli
sudo a2enmod brotli


    BrotliCompressionQuality 5
    AddOutputFilterByType BROTLI_COMPRESS text/html text/plain text/css application/javascript application/json image/svg+xml

KeepAlive 설정

# /etc/apache2/apache2.conf

# KeepAlive 활성화
KeepAlive On

# 최대 요청 수
MaxKeepAliveRequests 100

# 타임아웃 (초)
KeepAliveTimeout 5

MPM 설정 최적화

# /etc/apache2/mods-available/mpm_event.conf


    StartServers             2
    MinSpareThreads          25
    MaxSpareThreads          75
    ThreadLimit              64
    ThreadsPerChild          25
    MaxRequestWorkers        150
    MaxConnectionsPerChild   0

디렉토리 구조

Apache 설정 파일 구조

/etc/apache2/
├── apache2.conf              # 메인 설정 파일
├── ports.conf                # 포트 설정
├── conf-available/           # 사용 가능한 설정
├── conf-enabled/             # 활성화된 설정
├── mods-available/           # 사용 가능한 모듈
├── mods-enabled/             # 활성화된 모듈 (심볼릭 링크)
├── sites-available/          # 사용 가능한 가상호스트
│   ├── 000-default.conf
│   ├── testdomain.conf
│   └── api.testdomain.conf
├── sites-enabled/            # 활성화된 가상호스트 (심볼릭 링크)
│   ├── 000-default.conf -> ../sites-available/000-default.conf
│   └── testdomain.conf -> ../sites-available/testdomain.conf
└── envvars                   # 환경 변수

웹 컨텐츠 디렉토리

/var/www/
├── html/                     # 기본 DocumentRoot
├── testdomain/               # 가상호스트 디렉토리
│   ├── public/
│   ├── index.html
│   └── .htaccess
└── logs/                     # 로그 (선택사항)

유용한 명령어 모음

빠른 참조

# 설정 테스트
sudo apache2ctl configtest

# 가상호스트 목록
sudo apache2ctl -S

# 설정 리로드 (무중단)
sudo systemctl reload apache2

# 재시작
sudo systemctl restart apache2

# 상태 확인
sudo systemctl status apache2

# 로그 실시간 모니터링
sudo tail -f /var/log/apache2/error.log

# 특정 도메인 설정 확인
sudo apache2ctl -D DUMP_VHOSTS | grep testdomain

# 활성화된 모듈 목록
apache2ctl -M

# 설정 파일 문법 체크
sudo apachectl -t

자주 사용하는 작업

# 새 가상호스트 생성부터 활성화까지
sudo vim /etc/apache2/sites-available/newsite.conf
sudo a2ensite newsite.conf
sudo apache2ctl configtest
sudo systemctl reload apache2

# SSL 인증서 발급 및 자동 설정
sudo certbot --apache -d newsite.com

# 로그 분석
sudo tail -1000 /var/log/apache2/access.log | grep "POST" | wc -l

# 디스크 사용량 확인
sudo du -sh /var/log/apache2/*

# 오래된 로그 정리
sudo find /var/log/apache2/ -name "*.log.*" -mtime +30 -delete

문제 상황별 체크리스트

사이트가 접속되지 않을 때

[ ] Apache 서비스 작동 확인: sudo systemctl status apache2
[ ] 포트 리스닝 확인: sudo netstat -tlnp | grep :80
[ ] 방화벽 확인: sudo ufw status
[ ] DNS 설정 확인: nslookup testdomain.com
[ ] 가상호스트 활성화 확인: sudo apache2ctl -S
[ ] 설정 문법 확인: sudo apache2ctl configtest

502 Bad Gateway 발생 시

[ ] 백엔드 서비스 작동 확인: curl http://localhost:3000/
[ ] 프록시 설정 확인: ProxyPass, ProxyPassReverse
[ ] SELinux 설정 확인 (CentOS/RHEL)
[ ] 타임아웃 설정 확인: ProxyTimeout
[ ] 에러 로그 확인: sudo tail -50 /var/log/apache2/error.log

SSL 인증서 오류 시

[ ] 인증서 파일 존재 확인
[ ] 인증서 유효기간 확인: sudo certbot certificates
[ ] 인증서 경로 확인
[ ] 포트 443 리스닝 확인
[ ] SSL 모듈 활성화 확인: apache2ctl -M | grep ssl

The post Apache Virtual Host Guide (Apache 가상 호스트 설정) appeared first on 어제와 내일의 나 그 사이의 이야기.

MySQL 서비스 관리 명령어 (Ubuntu)

lycos7560 — Wed, 13 Aug 2025 11:50:10 +0000

MySQL 서비스 관리 명령어

MySQL 서비스 관리 명령어

상태 확인

sudo systemctl status mysql

서비스 시작

sudo systemctl start mysql

서비스 재시작

# 설정 변경 후 MySQL 재시작 필요
sudo systemctl restart mysql

서비스 중지

sudo systemctl stop mysql

부팅 시 자동 시작

# 부팅 시 자동 시작 활성화
sudo systemctl enable mysql

# 부팅 시 자동 시작 비활성화
sudo systemctl disable mysql

설정 파일

sudo cat /etc/mysql/my.cnf

# 현재 상태 정보 확인
mysql -u root -p -e "SHOW STATUS;"

# MySQL 클라이언트로 현재 설정 값 확인
mysql -u root -p -e "SHOW VARIABLES;"

# 특정 설정 값만 필터링해서 보기 (예: buffer_pool_size)
mysql -u root -p -e "SHOW VARIABLES LIKE '%buffer_pool_size%';"

추가 유용한 명령어

# MySQL 프로세스 확인
ps aux | grep mysql

# MySQL 버전 확인
mysql -V
mysql -u root -p -e "SELECT version();"

# 사용자 목록 확인
mysql -u root -p -e "SELECT user, host FROM mysql.user;"

# 데이터베이스 목록 확인
mysql -u root -p -e "SHOW DATABASES;"

# 테이블 상태 확인
mysql -u root -p -e "SHOW TABLE STATUS;"

# 실행 중인 쿼리 확인
mysql -u root -p -e "SHOW PROCESSLIST;"

백업 및 복구

# 전체 데이터베이스 백업
sudo mysqldump -u root -p --all-databases > full_backup.sql

# 특정 데이터베이스 백업
sudo mysqldump -u root -p database_name > db_backup.sql

# 백업 파일로 복구
mysql -u root -p < full_backup.sql

The post MySQL 서비스 관리 명령어 (Ubuntu) appeared first on 어제와 내일의 나 그 사이의 이야기.

ASP.NET Core Identity를 활용한 구글 로그인(OAuth) 전체 흐름 분석

lycos7560 — Fri, 08 Aug 2025 07:45:23 +0000

ASP.NET Core Identity를 활용한 구글 로그인(OAuth) 전체 흐름 분석

ASP.NET Core Identity를 활용한 구글 로그인(OAuth) 전체 흐름 분석

1⃣ 사용자가 “Google로 로그인” 버튼을 클릭

Navigation.NavigateTo(..., forceLoad: true)

Blazor의 내부 라우팅이 아닌, 브라우저가 직접 해당 URL(api/auth/Challenge/Google...)로 GET 요청보낸다.

private void LoginWithGoogle()
{
    var returnUrl = "/"; // 로그인 성공 후 돌아올 주소
    var googleLoginUrl = $"/api/auth/Challenge/Google?returnUrl={Uri.EscapeDataString(returnUrl)}";

    // 이 주소로 브라우저가 페이지를 새로고침하며 이동
    Navigation.NavigateTo(googleLoginUrl, forceLoad: true);
}

2⃣ 백엔드의 인증 시작 (AuthController – Challenge)

// AuthController.cs
[HttpGet("Challenge/{provider}")]
public IActionResult Challenge(string provider, string? returnUrl = null)
{
    // ...
    var redirectUrl = Url.Action("Callback", "Auth", ...); // 1. Google이 인증 후 돌아올 우리 API 주소(Callback)를 지정
    var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl); // 2. 인증 요청에 필요한 속성 구성

    return Challenge(properties, provider); // 3. Google 로그인 페이지로 리디렉션하는 응답 생성
}

AuthController.cs의 Challenge 메서드가 실행됩니다.
provider 매개변수에는 “Google”이 전달
_signInManager는 ASP.NET Core Identity의 핵심 기능으로, 외부 로그인 과정을 도와줌
return Challenge(properties, provider);는 브라우저에게 HTTP 302 Redirect 응답을 보냄
이 응답 헤더에는 사용자가 이동해야 할 Google의 로그인 페이지 주소가 포함

3⃣ 외부 공급자 인증 (Google)

사용자는 Google 로그인 페이지로 이동

사용자는 자신의 Google 계정으로 로그인하고, 우리 애플리케이션이 요청하는 정보(이메일, 프로필 등)에 대한 접근 권한을 허용
인증이 성공적으로 완료되면, Google은 2단계에서 백엔드가 지정했던 콜백 URL(api/Auth/Callback)로 사용자를 다시 리디렉션
이때 인증 코드 또는 토큰과 함께 사용자를 보냄

4⃣ 백엔드의 콜백 처리 및 로그인/회원가입 (AuthController – Callback)

Google이 사용자를 우리 백엔드의 Callback 엔드포인트로 돌려보냄

AuthController.cs의 Callback (라우팅 경로: externalLogin) 메서드가 실행

// AuthController.cs
[HttpGet("externalLogin")]
public async Task Callback(...)
{
    // 1. Google이 보내준 정보로 외부 로그인 정보를 가져옴
    var info = await _signInManager.GetExternalLoginInfoAsync();
    if (info == null) { /* 에러 처리 */ }

    // 2. 이 외부 정보(공급자, 키)로 우리 DB에 연결된 사용자가 있는지 확인하고 로그인 시도
    var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, ...);

    if (result.Succeeded)
    {
        // 3a. 성공! 이미 가입하고 연동된 사용자. 로그인 처리 후 returnUrl로 리디렉션
        return LocalRedirect(returnUrl);
    }
    else
    {
        // 3b. 실패. 신규 사용자이거나, 이메일은 같지만 연동되지 않은 사용자.
        return await HandleUserCreationOrLinking(info, returnUrl);
    }
}

HandleUserCreationOrLinking 메서드는 다음 두 가지 시나리오를 처리

시나리오 A: 이메일은 존재하지만 소셜 연동이 안 된 경우 (LinkExistingUser)
- Google에서 받은 이메일로 우리 DB에서 사용자를 찾습니다. (_userManager.FindByEmailAsync)
- 기존 사용자가 있다면, 해당 계정에 이 Google 로그인 정보를 추가로 연결합니다. (_userManager.AddLoginAsync)
- 연결 후, 사용자를 로그인시키고 returnUrl로 리디렉션합니다.
시나리오 B: 완전히 새로운 사용자인 경우 (CreateNewUserAsync)
- Google에서 받은 이메일과 이름으로 새로운 ApplicationUser 객체를 만듭니다. 이때 EmailConfirmed는 true로 설정합니다. (소셜 로그인은 이미 이메일이 인증된 것으로 간주)
- _userManager.CreateAsync(user)로 DB에 새 사용자를 저장합니다.
- 새로 생성된 사용자 계정에 Google 로그인 정보를 연결합니다. (_userManager.AddLoginAsync)
- 새 사용자를 로그인시키고 returnUrl로 리디렉션합니다.

5⃣ 완료

로그인 또는 회원가입 및 연동이 모두 성공적으로 끝나면, 백엔드는 최종적으로 LocalRedirect(returnUrl)을 통해 사용자를 맨 처음 Login.razor에서 지정했던 주소(/)로 리디렉션합니다.

이제 사용자는 로그인된 상태로 메인 페이지를 보게 됩니다.

6⃣ AuthController.cs

using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.WebUtilities;
using Microsoft.IdentityModel.Tokens;
using Neco.BaseTemplate.Shared.Data;
using Neco.BaseTemplete.Data;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using System.Text.Encodings.Web;

namespace Neco.BaseTemplete.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class AuthController : ControllerBase
    {
        private readonly UserManager _userManager;
        private readonly SignInManager _signInManager;
        private readonly IUserStore _userStore;
        private readonly IEmailSender _emailSender;
        private readonly ILogger _logger;

        public AuthController(
            UserManager userManager,
            SignInManager signInManager,
            IUserStore userStore,
            IEmailSender emailSender,
            ILogger logger)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _userStore = userStore;
            _emailSender = emailSender;
            _logger = logger;
        }

        #region Basic Authentication

        /// 
        /// Handles user login.
        /// 
        /// Login request DTO (email, password, RememberMe option)
        /// The login result
        [HttpPost("login")]
        public async Task Login([FromBody] LoginUserRequestDTO model)
        {
            try
            {
                var result = await _signInManager.PasswordSignInAsync(
                    model.Email,
                    model.Password,
                    model.RememberMe,
                    lockoutOnFailure: true);

                if (result.Succeeded)
                {
                    _logger.LogInformation("User logged in: {Email}", model.Email);
                    return Ok(new { Success = true });
                }

                if (result.RequiresTwoFactor)
                {
                    return Ok(new { RequiresTwoFactor = true });
                }

                if (result.IsLockedOut)
                {
                    _logger.LogWarning("User account locked out: {Email}", model.Email);
                    return BadRequest("Account locked out");
                }

                return BadRequest("Invalid login attempt");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Login error for {Email}", model.Email);
                return StatusCode(500, "An error occurred");
            }
        }

        /// 
        /// Handles new user registration.
        /// 
        /// Registration request DTO
        /// The registration result
        [HttpPost("register")]
        public async Task Register([FromBody] CreateUserRequestDTO model)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(new RegisterUserResponseDTO
                {
                    Status = RegisterUserResponseDTO.ResponseStatus.Fail_RequestInvalid,
                    Errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage)
                });
            }

            var user = CreateUser();
            await _userStore.SetUserNameAsync(user, model.Email, CancellationToken.None);
            var emailStore = GetEmailStore();
            await emailStore.SetEmailAsync(user, model.Email, CancellationToken.None);

            var result = await _userManager.CreateAsync(user, model.Password);

            if (!result.Succeeded)
            {
                _logger.LogInformation("User registration failed: {Email}", model.Email);

                // Handle duplicate email error
                if (result.Errors.Any(e => e.Code == "DuplicateUserName"))
                {
                    return BadRequest(new RegisterUserResponseDTO
                    {
                        Status = RegisterUserResponseDTO.ResponseStatus.Fail_DuplicateEmail,
                    });
                }

                // Handle general Identity errors
                return BadRequest(new RegisterUserResponseDTO
                {
                    Status = RegisterUserResponseDTO.ResponseStatus.Fail_General,
                    Errors = result.Errors.Select(e => e.Description)
                });
            }

            _logger.LogInformation("User created a new account with a password.");

            // Send email confirmation link
            try
            {
                var userId = await _userManager.GetUserIdAsync(user);
                var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

                // NOTE: For security, it's recommended to configure a fixed base URL
                // from your application's settings rather than relying on the request host.
                var baseUrl = model.BaseUrl ?? $"{Request.Scheme}://{Request.Host.Value}";
                var callbackUrl = $"{baseUrl}/Account/ConfirmEmail?userId={userId}&code={code}";

                await _emailSender.SendConfirmationLinkAsync(user, model.Email, HtmlEncoder.Default.Encode(callbackUrl));
            }
            catch (Exception)
            {
                // Account created successfully but email sending failed.
                return Ok(new RegisterUserResponseDTO
                {
                    Status = RegisterUserResponseDTO.ResponseStatus.Success_EmailWarning,
                    Message = "The account was created, but the verification email sending failed."
                });
            }

            return Ok(new RegisterUserResponseDTO
            {
                Status = RegisterUserResponseDTO.ResponseStatus.Success_NeedConfirmation
            });
        }

        /// 
        /// Resends the email confirmation link.
        /// 
        /// Email confirmation request DTO
        /// The result of the process
        [HttpPost("emailConfirm")]
        public async Task ResendEmailConfirm([FromBody] RequestEmailConfirmDTO model)
        {
            if (!ModelState.IsValid)
            {
                // Always return a success response for security (to avoid user enumeration).
                return Ok(new ResponseEmailConfirmDTO
                {
                    Status = ResponseEmailConfirmDTO.ResponseStatus.Success,
                    Message = "The confirmation email has been sent successfully."
                });
            }

            try
            {
                var user = await _userManager.FindByEmailAsync(model.Email);

                // Even if the user doesn't exist or is already confirmed, return a success response for security.
                if (user == null || user.EmailConfirmed)
                {
                    return Ok(new ResponseEmailConfirmDTO
                    {
                        Status = ResponseEmailConfirmDTO.ResponseStatus.Success,
                        Message = "The confirmation email has been sent successfully."
                    });
                }

                // Generate and send the email confirmation link
                var userId = await _userManager.GetUserIdAsync(user);
                var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

                // NOTE: It is recommended to use a pre-configured base URL.
                var baseUrl = model.BaseUrl ?? $"{Request.Scheme}://{Request.Host.Value}";
                var callbackUrl = $"{baseUrl}/Account/ConfirmEmail?userId={userId}&code={code}";

                await _emailSender.SendConfirmationLinkAsync(user, model.Email, HtmlEncoder.Default.Encode(callbackUrl));

                return Ok(new ResponseEmailConfirmDTO
                {
                    Status = ResponseEmailConfirmDTO.ResponseStatus.Success,
                    Message = "The confirmation email has been sent successfully."
                });
            }
            catch (Exception)
            {
                // Mail server or other exception occurred.
                return BadRequest(new ResponseEmailConfirmDTO
                {
                    Status = ResponseEmailConfirmDTO.ResponseStatus.Fail,
                    Message = $"An error occurred while processing your request. (Server Error)"
                });
            }
        }

        /// 
        /// Handles password reset requests.
        /// 
        /// Password reset request DTO
        /// The result of the process
        [HttpPost("resetPassword")]
        public async Task ResetPassword([FromBody] ResetPasswordRequestDTO model)
        {
            var user = await _userManager.FindByEmailAsync(model.Email);
            if (user == null)
            {
                return BadRequest("User not found");
            }

            var resetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
            var callbackUrl = $"{model.BaseUrl}/Account/ResetPassword?email={model.Email}&token={resetToken}";

            await _emailSender.SendPasswordResetLinkAsync(user, model.Email, callbackUrl);

            return Ok("Password reset link sent");
        }

        /// 
        /// Handles user logout.
        /// 
        /// The logout result
        [HttpPost("logout")]
        public async Task Logout()
        {
            await _signInManager.SignOutAsync();
            return Ok("Logged out successfully");
        }

        /// 
        /// Handles the generation of a JWT token.
        /// 
        /// Login request DTO (email, password)
        /// Token information
        [HttpPost("token")]
        public async Task GenerateToken([FromBody] LoginUserRequestDTO model)
        {
            var user = await _userManager.FindByEmailAsync(model.Email);
            if (user == null || !await _userManager.CheckPasswordAsync(user, model.Password))
            {
                return Unauthorized("Invalid credentials");
            }

            var claims = new[]
            {
                new Claim(ClaimTypes.Name, user.UserName),
                new Claim(ClaimTypes.Email, user.Email)
            };

            // WARNING: Do not hard-code the key in production.
            // Move this to a secure configuration file (e.g., appsettings.json)
            // and use a strong, randomly generated key.
            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("A_Very_Strong_And_Secret_Key_For_JWT_Auth"));
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

            var token = new JwtSecurityToken(
                issuer: "yourdomain.com",
                audience: "yourdomain.com",
                claims: claims,
                expires: DateTime.Now.AddMinutes(30),
                signingCredentials: creds);

            return Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token) });
        }

        #endregion

        #region External Authentication (OAuth)

        /// 
        /// Initiates a challenge request to an external authentication provider (e.g., Google).
        /// 
        /// The name of the authentication provider (e.g., "Google")
        /// The URL to redirect to after successful authentication
        /// A challenge result to the external provider
        [HttpGet("Challenge/{provider}")]
        public IActionResult Challenge(string provider, string? returnUrl = null)
        {
            _logger.LogInformation("Starting {Provider} login", provider);

            if (string.IsNullOrWhiteSpace(provider))
            {
                return BadRequest(new { error = "Provider not specified." });
            }

            // Normalize and validate returnUrl
            returnUrl = NormalizeReturnUrl(returnUrl);

            // Set the callback URL
            var redirectUrl = Url.Action("Callback", "Auth", new { returnUrl }, Request.Scheme);

            // Configure authentication properties
            var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl);

            return Challenge(properties, provider);
        }

        /// 
        /// Handles the callback from an external authentication provider.
        /// 
        /// The URL to redirect to after successful authentication
        /// Error message from the external provider
        /// An appropriate response based on the authentication result
        [HttpGet("externalLogin")]
        public async Task Callback(string? returnUrl = null, string? remoteError = null)
        {
            try
            {
                returnUrl = NormalizeReturnUrl(returnUrl);

                if (!string.IsNullOrEmpty(remoteError))
                {
                    _logger.LogError("External provider error: {RemoteError}", remoteError);
                    return Redirect($"/login?error={Uri.EscapeDataString(remoteError)}");
                }

                var info = await _signInManager.GetExternalLoginInfoAsync();
                if (info == null)
                {
                    _logger.LogError("Could not retrieve external login info");
                    return Redirect("/login?error=external_login_failed");
                }

                // Attempt to sign in an existing user
                var result = await _signInManager.ExternalLoginSignInAsync(
                    info.LoginProvider,
                    info.ProviderKey,
                    isPersistent: false,
                    bypassTwoFactor: true);

                if (result.Succeeded)
                {
                    var user = await _userManager.FindByLoginAsync(info.LoginProvider, info.ProviderKey);
                    _logger.LogInformation("User {Email} successfully logged in", user?.Email);
                    return LocalRedirect(returnUrl);
                }

                if (result.IsLockedOut)
                {
                    _logger.LogWarning("Attempt to log in with a locked-out account");
                    return Redirect("/login?error=locked_out");
                }

                // New user or linking an existing user
                return await HandleUserCreationOrLinking(info, returnUrl);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while processing external login");
                return Redirect("/login?error=server_error");
            }
        }

        #endregion

        #region Helper Methods

        /// 
        /// Normalizes and validates the returnUrl.
        /// 
        private string NormalizeReturnUrl(string? returnUrl)
        {
            if (string.IsNullOrWhiteSpace(returnUrl))
                return "/";

            if (Uri.TryCreate(returnUrl, UriKind.Absolute, out var uri))
                returnUrl = uri.PathAndQuery;

            return Url.IsLocalUrl(returnUrl) ? returnUrl : "/";
        }

        /// 
        /// Handles new user creation or linking an existing user to an external login.
        /// 
        private async Task HandleUserCreationOrLinking(ExternalLoginInfo info, string returnUrl)
        {
            var email = info.Principal.FindFirstValue(ClaimTypes.Email);
            if (string.IsNullOrEmpty(email))
            {
                _logger.LogError("Missing email information from external provider {Provider}", info.LoginProvider);
                return Redirect("/login?error=email_required");
            }

            var existingUser = await _userManager.FindByEmailAsync(email);
            return existingUser != null
                ? await LinkExistingUser(existingUser, info, returnUrl)
                : await CreateNewUserAsync(info, returnUrl);
        }

        /// 
        /// Links external login information to an existing user.
        /// 
        private async Task LinkExistingUser(ApplicationUser user, ExternalLoginInfo info, string returnUrl)
        {
            var addLoginResult = await _userManager.AddLoginAsync(user, info);
            if (addLoginResult.Succeeded)
            {
                _logger.LogInformation("Successfully linked {Provider} login to existing user {Email}", info.LoginProvider, user.Email);
                await _signInManager.SignInAsync(user, isPersistent: false, info.LoginProvider);
                return LocalRedirect(returnUrl);
            }

            _logger.LogError("Failed to link external login to existing user: {Errors}",
                string.Join(", ", addLoginResult.Errors.Select(e => e.Description)));
            return Redirect("/login?error=link_failed");
        }

        /// 
        /// Creates a new user based on external login information.
        /// 
        private async Task CreateNewUserAsync(ExternalLoginInfo info, string returnUrl)
        {
            var email = info.Principal.FindFirstValue(ClaimTypes.Email);
            if (string.IsNullOrEmpty(email))
            {
                _logger.LogError("Missing email information from external provider");
                return BadRequest(new { error = "Email information was not provided." });
            }

            var userName = email.Split('@')[0];
            var user = new ApplicationUser
            {
                UserName = email,
                Email = email,
                NickName = userName,
                EmailConfirmed = true // Email is already confirmed via external provider
            };

            var createResult = await _userManager.CreateAsync(user);
            if (!createResult.Succeeded)
            {
                _logger.LogError("User creation failed: {Errors}",
                    string.Join(", ", createResult.Errors.Select(e => e.Description)));

                // Attempt to create an alternative user name on a naming conflict
                if (createResult.Errors.Any(e => e.Code == "DuplicateUserName"))
                {
                    user.UserName = $"{userName}_{Guid.NewGuid().ToString("N").Substring(0, 4)}";
                    createResult = await _userManager.CreateAsync(user);

                    if (!createResult.Succeeded)
                    {
                        return BadRequest(new
                        {
                            error = "Account creation failed",
                            details = createResult.Errors.Select(e => e.Description)
                        });
                    }
                }
                else
                {
                    return BadRequest(new
                    {
                        error = "Account creation failed",
                        details = createResult.Errors.Select(e => e.Description)
                    });
                }
            }

            // Link external login information
            var addLoginResult = await _userManager.AddLoginAsync(user, info);
            if (!addLoginResult.Succeeded)
            {
                _logger.LogError("Failed to add login information: {Errors}",
                    string.Join(", ", addLoginResult.Errors.Select(e => e.Description)));

                // Rollback: Delete the created user
                await _userManager.DeleteAsync(user);

                return BadRequest(new
                {
                    error = "Failed to link external login information",
                    details = addLoginResult.Errors.Select(e => e.Description)
                });
            }

            _logger.LogInformation("New user created and logged in successfully: {Email}", email);
            await _signInManager.SignInAsync(user, isPersistent: false, info.LoginProvider);

            return LocalRedirect(returnUrl);
        }

        private ApplicationUser CreateUser()
        {
            try
            {
                return Activator.CreateInstance();
            }
            catch
            {
                throw new InvalidOperationException($"Can't create an instance of '{nameof(ApplicationUser)}'. " +
                    $"Ensure that '{nameof(ApplicationUser)}' is not an abstract class and has a parameterless constructor.");
            }
        }

        private IUserEmailStore GetEmailStore()
        {
            if (!_userManager.SupportsUserEmail)
            {
                throw new NotSupportedException("The default UI requires a user store with email support.");
            }
            return (IUserEmailStore)_userStore;
        }

        #endregion

        #region Profile Management

        /// 
        /// Handles user profile updates.
        /// 
        /// Update request DTO
        /// The result of the process
        [HttpPut("updateProfile")]
        public async Task UpdateProfile([FromBody] UpdateUserProfileDTO model)
        {
            var user = await _userManager.FindByIdAsync(model.Email);
            if (user == null)
            {
                return NotFound("User not found");
            }

            user.NickName = model.Nickname;
            user.PhoneNumber = model.PhoneNumber;

            var result = await _userManager.UpdateAsync(user);
            if (!result.Succeeded)
            {
                return BadRequest(result.Errors.Select(e => e.Description));
            }

            return Ok("Profile updated successfully");
        }

        /// 
        /// Handles user deletion.
        /// 
        /// The ID of the user to delete
        /// The result of the process
        [HttpDelete("deleteUser/{userId}")]
        public async Task DeleteUser(string userId)
        {
            var user = await _userManager.FindByIdAsync(userId);
            if (user == null)
            {
                return NotFound("User not found");
            }

            var result = await _userManager.DeleteAsync(user);
            if (!result.Succeeded)
            {
                return BadRequest(result.Errors.Select(e => e.Description));
            }

            return Ok("User deleted successfully");
        }

        #endregion
    }
}

private void LoginWithGoogle()
{
    try
    {
        var returnUrl = "/";
        var googleLoginUrl = $"/api/auth/Challenge/Google?returnUrl={Uri.EscapeDataString(returnUrl)}";

        // Redirect in the current window instead of a popup
        // This is a placeholder for a client-side navigation method, e.g., in Blazor
        // Navigation.NavigateTo(googleLoginUrl, forceLoad: true);
    }
    catch (Exception ex)
    {
        // Error handling
        Console.WriteLine($"Google login error: {ex.Message}");
    }
}

The post ASP.NET Core Identity를 활용한 구글 로그인(OAuth) 전체 흐름 분석 appeared first on 어제와 내일의 나 그 사이의 이야기.

Docker 백그라운드 실행 명령어

lycos7560 — Thu, 31 Jul 2025 18:54:54 +0000

1. Docker 백그라운드 실행 명령어
2. 실행 중인 컨테이너 확인 명령어
3. 모든 컨테이너 확인 명령어 (실행 중 + 정지)
4. 기타 유용한 명령어

1. Docker 백그라운드 실행 명령어

컨테이너를 백그라운드(detached) 모드로 실행하여 터미널을 점유하지 않고 계속해서 동작하게 하는 명령어

// docker run -d [이미지 이름]
// -d 또는 --detach 옵션은 컨테이너를 백그라운드에서 실행하도록 지시
docker run -d -p 8080:80 nginx

2. 실행 중인 컨테이너 확인 명령어

현재 시스템에서 실행 중인 컨테이너를 확인하는 명령어

// ps는 "process status"의 약자로, 현재 실행 중인 컨테이너의 목록을 보여줌
docker ps


CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                                   NAMES
a1b2c3d4e5f6   nginx     "/docker-entrypoint.sh"  10 seconds ago   Up 8 seconds    0.0.0.0:8080->80/tcp, :::8080->80/tcp   web_server

// CONTAINER ID: 컨테이너의 고유 ID
// IMAGE: 컨테이너를 생성하는 데 사용된 이미지
// COMMAND: 컨테이너가 실행될 때 사용된 명령어
// CREATED: 컨테이너가 생성된 시점
// STATUS: 컨테이너의 현재 상태 (예: Up 5 minutes)
// PORTS: 포트 매핑 정보
// NAMES: 컨테이너에 할당된 이름

3. 모든 컨테이너 확인 명령어 (실행 중 + 정지)

실행 중인 컨테이너뿐만 아니라, 이전에 실행되었다가 현재는 정지된 모든 컨테이너를 확인하는 명령어

// -a 또는 --all 옵션은 모든 컨테이너를 표시하도록 지시
docker ps -a

CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS                      PORTS     NAMES
a1b2c3d4e5f6   nginx     "/docker-entrypoint.sh"  2 minutes ago   Up 2 minutes                ...       web_server
e6f5d4c3b2a1   ubuntu    "/bin/bash"              5 hours ago     Exited (0) 4 minutes ago              test_container

4. 기타 유용한 명령어

docker stop
docker start
docker kill
docker logs
docker attach
docker exec

// 컨테이너 중지: docker stop [컨테이너 ID 또는 이름]
// 실행 중인 컨테이너를 정상적으로 종료시킵니다.
docker stop web_server

// 컨테이너 시작: docker start [컨테이너 ID 또는 이름]
// 정지된 컨테이너를 다시 시작합니다.
docker start test_container

// 컨테이너 강제 종료: docker kill [컨테이너 ID 또는 이름]
// 컨테이너를 강제로 즉시 종료시킵니다.
docker kill web_server

// 컨테이너 로그 확인: docker logs [컨테이너 ID 또는 이름]
// 컨테이너의 표준 출력(stdout)과 표준 에러(stderr) 로그를 확인합니다.
docker logs web_server

// 컨테이너 접속: docker attach [컨테이너 ID 또는 이름]
// 백그라운드에서 실행 중인 컨테이너의 터미널에 연결합니다.
docker attach web_server

// 컨테이너 내부에 명령어 실행: docker exec [컨테이너 ID 또는 이름] [명령어]
// 실행 중인 컨테이너 내부에 새로운 프로세스를 실행합니다.
// 예시 : Nginx 컨테이너에서 bash 셸을 실행하여 내부로 접속
docker exec -it web_server /bin/bash

The post Docker 백그라운드 실행 명령어 appeared first on 어제와 내일의 나 그 사이의 이야기.

Docker Port Mapping(포트 매핑)

lycos7560 — Thu, 31 Jul 2025 18:29:11 +0000

Docker 포트 매핑 (Port Mapping)

Docker 포트 매핑 (Port Mapping)

Docker에서 포트 매핑은 컨테이너 내부에서 실행 중인 서비스의 포트와 호스트 컴퓨터(Docker가 설치된 머신)의 포트를 연결하는 중요한 기능입니다.

포트 매핑 왜 필요한가?

Docker 컨테이너는 기본적으로 격리된 환경에서 실행됩니다.

즉, 컨테이너 내부에 웹 서버가 80번 포트에서 동작하더라도, 외부에서는 이 포트에 직접 접근할 수 없습니다.

컨테이너는 자체적인 IP 주소를 가지고 있으며, 호스트 컴퓨터와는 다른 네트워크 환경에 있습니다.

포트 매핑의 역할

포트 매핑은 컨테이너의 특정 포트를 호스트 컴퓨터의 특정 포트로 터널링(tunneling)하는 역할을 합니다.

이를 통해 외부 사용자는 호스트 컴퓨터의 포트를 통해 컨테이너 내부의 서비스에 접근할 수 있게 됩니다.

간단한 예시

Nginx 웹 서버를 실행하는 컨테이너를 생각해봅시다.

Nginx는 기본적으로 80번 포트에서 동작합니다.

이 컨테이너에 외부에서 접근할 수 있도록 하려면 다음과 같이 포트 매핑을 설정할 수 있습니다.

Bash

docker run -p 8080:80 nginx

-p:
포트 매핑 옵션
8080:
호스트 컴퓨터의 포트로 외부에서 http://[호스트 IP]:8080으로 접속
80:
컨테이너 내부의 포트로 Nginx가 이 포트에서 대기
nginx:
사용할 Docker 이미지 이름

호스트 컴퓨터의 8080번 포트로 들어오는 모든 네트워크 요청은 Docker에 의해 컨테이너의 80번 포트로 전달됩니다.

이로써 외부 사용자는 http://localhost:8080 (만약 로컬에서 실행했다면)으로 접속하여 컨테이너 내부의 Nginx 웹 서버에 접근할 수 있게 됩니다.

요약

개념	설명
컨테이너 포트	컨테이너 내부에서 서비스가 실제로 사용하고 있는 포트 (예: Nginx의 80번 포트)
호스트 포트	컨테이너에 접근하기 위해 외부에서 사용하는, 호스트 컴퓨터의 포트
포트 매핑	[호스트 포트]:[컨테이너 포트] 형태로 두 포트를 연결하는 과정

The post Docker Port Mapping(포트 매핑) appeared first on 어제와 내일의 나 그 사이의 이야기.

Docker에서 HTML 페이지 배포

lycos7560 — Thu, 31 Jul 2025 17:13:30 +0000

Docker에서 HTML 페이지 배포

Docker에서 HTML 페이지 배포

기본적으로 웹 서버로 이동하여 HTML 페이지를 렌더링

웹 서버 nginx 이미지 가져오기

docker pull nginx

index.html 파일을 준비

테스트 페이지

HTML 테스트 페이지

이 페이지는 테스트용으로 생성되었습니다.

nginx 이미지를 사용하여 Docker 컨테이너에 로드

Dockerfile 생성

도커파일은 확장자가 없음

FROM nginx
COPY ./SampleWebApp/ /usr/share/nginx/html

Dockerfile 이미지 생성

도커파일은 확장자가 없음

cd C:\Users\IKHO\Desktop\Docker 
// dockerfile 위치로 이동

ls 
// 파일 목록 확인

docker build -t sample_web_app:1.0.0 .
// docker build: 현재 디렉터리에 있는 Dockerfile을 기반으로 Docker 이미지를 만들라는 명령입니다.
// -t sample_web_app:1.0.0: 생성될 이미지의 이름과 태그를 지정합니다.
// sample_web_app이 이미지 이름
// 1.0.0은 버전 또는 태그 (나중에 버전별로 관리할 때 유용)

컨테이너를 생성 및 실행

docker run --name sample_web_app-container -p 9000:80 sample_web_app:1.0.0
// docker run   : 새로운 컨테이너를 생성하고 실행합니다
// --name sample_web_app-container   : 컨테이너의 이름을 sample_web_app-container로 설정합니다
// -p 9000:80   : 포트 매핑: 호스트의 9000 포트를 컨테이너의 80 포트에 연결합니다 (외부에서 localhost:9000으로 접근 가능)
// sample_web_app:1.0.0   : sample_web_app라는 이름과 1.0.0 태그가 붙은 이미지를 기반으로 컨테이너를 생성합니다



http://127.0.0.1:9000/

The post Docker에서 HTML 페이지 배포 appeared first on 어제와 내일의 나 그 사이의 이야기.

기본적인 Docker 명령어 연습

lycos7560 — Wed, 30 Jul 2025 14:02:17 +0000

기본적인 Docker 명령어
.NET Image 추가

기본적인 Docker 명령어

PowerShell 에서 Docker 버전 확인

docker --version

// Docker Hub에서 hello-world 이미지를 다운로드하는 명령어
docker pull hello-world

처음에는 docker를 잠시 멈추어 놓아서 실패

다운로드 완료 후 이미지 확인

docker images

Desktop에서도 확인이 가능하

hello-world 이미지 실행

docker run hello-world

// 실행 중인 컨테이너 목록만 출력
docker ps

모든 컨테이너 목록 출력
// 중지된, 종료된, 에러 난 컨테이너도 포함해서 모두 보여줌
docker ps -a

이미지를 제거하려면 실행중인 container를 모두 제거해야한다.

docker ps // 컨테이너 확인
docker ps -a // 모든 컨테이너 확인
docker rm 5fea
docker rm 6c465
docker rm 0fe
docker rm 1957
docker ps -a // 모든 컨테이너 확인
docker images // 이미지 검색
docker rmi ec1538 // 이미지 제거

이미지 제거 적용됨

docker run -d ubuntu sleep 10

항목	의미
`docker run`	새로운 컨테이너를 생성하고 실행
`-d`	Detached mode → 백그라운드에서 실행
`ubuntu`	사용할 이미지 이름 (없으면 자동으로 Docker Hub에서 pull함)
`sleep 10`	컨테이너 내부에서 실행할 명령어 (10초 동안 대기)

.NET Image 추가

https://hub.docker.com/r/microsoft/dotnet-sdk

docker pull mcr.microsoft.com/dotnet/sdk:8.0
docker images

두 항목의 IMAGE ID가 동일
REPOSITORY: mcr.microsoft.com/dotnet/sdk
TAG: 9.0 → IMAGE ID: 08fe223b9022
TAG: latest → IMAGE ID: 08fe223b9022
이유: latest 태그는 별칭(alias) 이기 때문이다
도커에서 태그(TAG)는 특정 이미지 버전을 지칭하는 이름일 뿐이며, 동일한 이미지에 여러 개의 태그를 붙일 수 있습니다.
=> 9.0 버전의 이미지에 latest라는 이름을 추가로 붙여 놓은 것

The post 기본적인 Docker 명령어 연습 appeared first on 어제와 내일의 나 그 사이의 이야기.

Docker / Virtual Machine 차이점

lycos7560 — Wed, 30 Jul 2025 12:57:01 +0000

현대 소프트웨어 개발에서 가상화 기술은 필수적인 요소입니다.

전통적인 가상머신(Virtual Machine)과 Docker 컨테이너 기술의 차이점을 알아봅니다.

Infrastructure (물리적 하드웨어)
Host OS (호스트 운영체제)
Hypervisor (가상화 관리자)
Guest OS (각 가상머신마다 독립된 운영체제)
bins/lib (각 VM마다 독립된 바이너리/라이브러리)
App 1, 2, 3 (애플리케이션들)

1. 아키텍처 비교

1.1 Virtual Machine 아키텍처

Virtual Machine은 다음과 같은 계층 구조를 가집니다:

특징:

각 가상머신은 독립된 Guest OS를 보유
하드웨어 가상화를 통한 완전한 격리
Hypervisor가 하드웨어 리소스 관리

1.2 Docker 아키텍처

Docker는 다음과 같은 경량화된 구조를 가집니다:

특징:

Guest OS 레이어 제거
Host OS 커널 공유
컨테이너 단위의 프로세스 격리

2. 핵심 차이점 분석

2.1 운영체제 레이어

구분	Virtual Machine	Docker
Guest OS	필수	불필요
커널	각 VM마다 독립	Host OS 커널 공유
부팅 과정	OS 전체 부팅	프로세스 시작

2.2 리소스 사용량

Virtual Machine

메모리: GB 단위 (OS + 애플리케이션)
디스크: 수 GB ~ 수십 GB
CPU: OS 오버헤드 포함
네트워크: 가상 네트워크 스택

Docker

메모리: MB 단위 (애플리케이션만)
디스크: MB ~ GB 단위
CPU: 최소한의 오버헤드
네트워크: Host 네트워크 스택 공유

2.3 성능 비교

항목	Virtual Machine	Docker
시작 시간	1-5분	1-10초
메모리 오버헤드	높음 (OS 포함)	낮음 (애플리케이션만)
I/O 성능	가상화 오버헤드	네이티브에 근접
밀도	낮음 (서버당 수십 개)	높음 (서버당 수백-수천 개)

3. 장단점 비교

3.1 Virtual Machine

장점

완전한 격리: 하드웨어 레벨의 보안 격리
OS 다양성: 다양한 운영체제 동시 실행 가능
성숙한 기술: 오랜 기간 검증된 안정성
강력한 보안: 하이퍼바이저 레벨 보안

단점

높은 리소스 사용량: OS 오버헤드
느린 시작: 부팅 시간 필요
관리 복잡성: 각 VM의 OS 관리 필요
낮은 밀도: 제한적인 VM 수

3.2 Docker

장점

경량성: 최소한의 리소스 사용
빠른 시작: 초 단위 컨테이너 시작
높은 밀도: 단일 호스트에 많은 컨테이너
일관성: “한 번 빌드, 어디서든 실행”
DevOps 친화적: CI/CD 파이프라인 최적화

단점

보안 취약점: 커널 공유로 인한 잠재적 위험
OS 제약: Linux 컨테이너는 Linux에서만
복잡한 네트워킹: 컨테이너 간 통신 설정
데이터 지속성: 컨테이너 재시작 시 데이터 손실 위험

4. 사용 사례별 권장사항

4.1 Virtual Machine이 적합한 경우

기업 환경

레거시 애플리케이션 운영
서로 다른 OS가 필요한 환경
강력한 보안 격리가 필요한 경우
규제 준수가 중요한 산업

기술적 요구사항

Windows와 Linux 애플리케이션 동시 운영
커널 수준의 소프트웨어 개발
완전한 네트워크 격리 필요
다양한 OS 버전 테스트

4.2 Docker가 적합한 경우

현대적 애플리케이션 개발

마이크로서비스 아키텍처
클라우드 네이티브 애플리케이션
지속적 통합/배포 (CI/CD)
개발 환경 표준화

운영 효율성

빠른 스케일링이 필요한 서비스
리소스 효율성이 중요한 환경
개발팀 간 환경 일관성
컨테이너 오케스트레이션 (Kubernetes)

5. 하이브리드 접근법

많은 조직에서는 두 기술을 함께 사용합니다:

5.1 VM 위의 Docker

VM으로 기본 격리 제공
VM 내에서 Docker로 애플리케이션 컨테이너화
보안과 효율성의 균형

5.2 클라우드 환경

AWS ECS, Google Cloud Run 등
관리형 컨테이너 서비스
인프라 추상화

6. 결론

Virtual Machine과 Docker는 각각 고유한 장점과 적용 영역을 가지고 있습니다.

Virtual Machine은 강력한 격리와 다양한 OS 지원이 필요한 전통적인 엔터프라이즈 환경에 적합하며,

Docker는 현대적인 클라우드 네이티브 애플리케이션 개발과 운영에 최적화되어 있습니다.

성공적인 시스템 설계를 위해서는 각 기술의 특성을 정확히 이해하고, 프로젝트의 요구사항에 맞는 적절한 선택을 하는 것이 중요합니다.

많은 경우 두 기술을 적절히 조합하여 사용하는 하이브리드 접근법이 최적의 결과를 제공할 수 있습니다.

The post Docker / Virtual Machine 차이점 appeared first on 어제와 내일의 나 그 사이의 이야기.