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

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 어제와 내일의 나 그 사이의 이야기.

ASP.NET Core – UseStaticFiles

lycos7560 — Sun, 13 Jul 2025 04:33:03 +0000

UseStaticFiles

UseStaticFiles

https://learn.microsoft.com/ko-kr/aspnet/core/fundamentals/static-files?view=aspnetcore-8.0

UseStaticFiles는 ASP.NET Core 애플리케이션에서 정적 파일(Static Files)을 제공하기 위해 사용되는 미들웨어입니다.

정적 파일이란 웹 서버가 클라이언트에 그대로 전달하는 파일들로, 웹 페이지를 구성하는 데 필요한 이미지, CSS 파일, JavaScript 파일, 폰트 등을 의미합니다.

1⃣ UseStaticFiles 미들웨어의 개념

ASP.NET Core는 기본적으로 보안을 위해 웹 루트(wwwroot 폴더) 외부의 파일에 대한 직접적인 웹 접근을 허용하지 않습니다.

UseStaticFiles 미들웨어는 이러한 제한을 해제하고, 웹 서버가 특정 디렉토리(기본값은 wwwroot)에 있는 정적 파일 요청을 처리할 수 있도록 파이프라인에 기능을 추가합니다.

이 미들웨어가 없으면, 브라우저가 /css/site.css나 /images/logo.png 같은 경로로 정적 파일을 요청했을 때, 서버는 해당 파일을 찾지 못하고 404 Not Found 오류를 반환하게 됩니다.

UseStaticFiles를 추가함으로써, ASP.NET Core 애플리케이션은 이러한 요청을 가로채어 지정된 위치에서 파일을 찾아 클라이언트에게 응답할 수 있게 됩니다.

2⃣ UseStaticFiles의 주요 역할

정적 파일 서빙 활성화:
웹 루트(wwwroot)에 있는 HTML, CSS, JavaScript, 이미지 등 정적 파일을 웹 브라우저가 요청할 수 있도록 허용합니다.
파일 경로 매핑:
들어오는 URL 요청을 서버의 실제 파일 시스템 경로에 매핑합니다.
캐싱 헤더 추가:
효율적인 캐싱을 위해 Cache-Control 같은 HTTP 응답 헤더를 자동으로 추가하여 브라우저가 정적 파일을 효율적으로 캐싱하고, 다음 요청 시 서버에 다시 요청하는 대신 로컬 캐시를 사용하도록 돕습니다.
MIME 타입 추론:
파일 확장자를 기반으로 올바른 MIME 타입(Content-Type 헤더)을 응답에 포함하여 브라우저가 파일을 올바르게 해석하도록 합니다.
디렉터리 브라우징 방지:
기본적으로 보안을 위해 디렉터리 목록을 보여주지 않습니다. (이를 허용하려면 추가 설정 필요)

3⃣ UseStaticFiles 사용 방법

UseStaticFiles 미들웨어는 보통 Program.cs 파일의 Configure 메서드에서 다른 미들웨어들과 함께 구성됩니다.

기본 사용법 (wwwroot 폴더)

가장 기본적인 사용법은 웹 루트(wwwroot) 폴더에 있는 정적 파일을 제공하는 것입니다.

이 경우, UseStaticFiles() 메서드를 인자 없이 호출하면 됩니다.

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorPages(); // 또는 AddControllersWithViews 등

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();

// UseStaticFiles 미들웨어를 추가합니다.
// 이는 wwwroot 폴더의 정적 파일을 제공합니다.
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages(); // 또는 app.MapControllerRoute 등

app.Run();

위 코드에서 UseStaticFiles()를 호출하면, ASP.NET Core 프로젝트 템플릿에 기본으로 생성되는 wwwroot 폴더의 내용이 웹에 노출됩니다.
예를 들어, wwwroot/css/site.css 파일이 있다면, 브라우저에서 http://localhost:포트번호/css/site.css로 접근할 수 있게 됩니다.

다른 폴더의 정적 파일 제공

wwwroot 외의 다른 폴더에 있는 정적 파일을 제공하고 싶을 때는 StaticFileOptions를 구성하여 경로를 지정할 수 있습니다.

// Program.cs

var builder = WebApplication.CreateBuilder(args);

// ... 서비스 설정 ...

var app = builder.Build();

// ... 기타 미들웨어 설정 ...

// wwwroot 외의 'MyStaticFiles' 폴더에 있는 정적 파일을 제공합니다.
// URL 경로는 `/MyFiles`로 시작합니다.
app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(
        Path.Combine(builder.Environment.ContentRootPath, "MyStaticFiles")),
    RequestPath = "/MyFiles" // URL 프리픽스
});

// 기존 wwwroot 폴더도 계속 사용하려면 이 줄도 유지합니다.
app.UseStaticFiles();

app.UseRouting();

// ... 나머지 미들웨어 및 엔드포인트 설정 ...

app.Run();

FileProvider: PhysicalFileProvider를 사용하여 서버의 실제 파일 시스템 경로를 지정합니다.
ContentRootPath는 애플리케이션의 기본 디렉토리를 나타냅니다.
RequestPath: 이 StaticFileOptions 인스턴스에 의해 제공되는 파일에 접근하기 위한 URL 프리픽스를 정의합니다.
위 예시에서는 MyStaticFiles 폴더에 있는 image.png 파일을 http://localhost:포트번호/MyFiles/image.png로 접근할 수 있습니다.
UseStaticFiles()를 여러 번 호출하여 여러 정적 파일 소스를 구성할 수 있습니다.

디렉터리 브라우징 활성화 (권장하지 않음)

보안상의 이유로 기본적으로 비활성화되어 있지만, 개발 목적으로 디렉터리 목록을 웹에 노출해야 하는 경우 UseDirectoryBrowser 미들웨어를 함께 사용할 수 있습니다.

// Program.cs

var builder = WebApplication.CreateBuilder(args);

// 서비스에 디렉터리 브라우징 추가
builder.Services.AddDirectoryBrowser();

var app = builder.Build();

// ... 기타 미들웨어 설정 ...

// 'MyDirectory' 폴더를 웹에 노출하고, 해당 폴더의 내용을 `/MyFolder` URL로 브라우징할 수 있도록 합니다.
app.UseDirectoryBrowser(new DirectoryBrowserOptions
{
    FileProvider = new PhysicalFileProvider(
        Path.Combine(app.Environment.ContentRootPath, "MyDirectory")),
    RequestPath = "/MyFolder"
});

// 'MyDirectory' 폴더의 정적 파일도 제공합니다.
app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(
        Path.Combine(app.Environment.ContentRootPath, "MyDirectory")),
    RequestPath = "/MyFolder"
});

// ... 나머지 미들웨어 및 엔드포인트 설정 ...

app.Run();

경고: UseDirectoryBrowser는 보안 취약점이 될 수 있으므로, 운영 환경에서는 절대 사용해서는 안 됩니다.
오직 개발/디버깅 목적으로만 제한적으로 사용해야 합니다.

4⃣ `UseStaticFiles` 미들웨어의 위치

미들웨어 파이프라인에서 UseStaticFiles의 위치는 중요합니다.

일반적으로 UseStaticFiles는 UseRouting 미들웨어 앞에 위치하는 것이 좋습니다.
이렇게 하면 라우팅 시스템이 복잡한 컨트롤러/엔드포인트 매칭 로직을 시작하기 전에, 정적 파일 요청을 먼저 빠르게 처리하고 응답할 수 있어 성능에 유리합니다.
만약 UseStaticFiles가 UseRouting 뒤에 오면, 정적 파일 요청도 라우팅 시스템의 대상이 되어 불필요한 처리 오버헤드가 발생할 수 있습니다.
하지만, 특정 미들웨어(예: 인증/인가 미들웨어)를 통해 정적 파일 접근을 제어하고 싶다면, 해당 미들웨어 뒤에 UseStaticFiles를 배치할 수도 있습니다.
이 경우 정적 파일 요청도 인증/인가 절차를 거치게 됩니다.

UseStaticFiles 미들웨어는 ASP.NET Core 웹 애플리케이션에서 정적인 웹 리소스를 효율적이고 안전하게 제공하는 데 필수적인 구성 요소입니다.

The post ASP.NET Core – UseStaticFiles appeared first on 어제와 내일의 나 그 사이의 이야기.

ASP.NET Core 파일 처리: FileResult 및 인터페이스

lycos7560 — Mon, 07 Jul 2025 07:59:28 +0000

ASP.NET Core 파일 처리: FileResult 및 인터페이스

리플렉션(Reflection)을 사용한 ActionResult를 상속받는 모든 클래스 찾기

ASP.NET Core 파일 처리: FileResult 및 인터페이스

ASP.NET Core 애플리케이션에서 파일은 핵심적인 요소입니다.

클라이언트로부터 파일을 업로드 받거나(Upload), 서버에 있는 파일을 클라이언트에게 제공(Download/Serve)하는 등 다양한 시나리오에서 파일을 효율적이고 안전하게 다루는 것이 중요합니다.

파일을 클라이언트에게 전송하는 주요 FileResult 유형(FileContentResult, VirtualFileResult, PhysicalFileResult)의 차이점과

파일 업로드, 파일 시스템 접근, 환경 정보 제공 등 파일 관련하여 알아야 할 핵심 인터페이스와 개념들을 정리합니다.

1⃣ File Download 및 Serving을 위한 FileResult 유형

ASP.NET Core MVC/API에서 컨트롤러 액션 메서드가 파일을 HTTP 응답으로 스트리밍할 때 사용하는 IActionResult의 파생 클래스들입니다.

파일 데이터를 가져오는 방식과 경로를 해석하는 방식에 따라 구분됩니다.

FileContentResult

https://learn.microsoft.com/ko-kr/dotnet/api/microsoft.aspnetcore.mvc.filecontentresult?view=aspnetcore-8.0

파일의 내용이 이미 byte[] 배열 형태로 메모리에 로드되어 있을 때 사용됩니다.

웹 서버는 이 바이트 배열을 그대로 클라이언트에게 스트리밍합니다.

정의:
Microsoft.AspNetCore.Mvc.FileContentResult
데이터 원본:
byte[] (메모리)
메모리 사용:
높음. 파일의 모든 내용이 메모리에 로드되므로, 큰 파일을 처리할 경우 메모리 부족 문제가 발생할 수 있습니다.
성능:
작은 파일이나 동적으로 생성된 파일에 적합합니다. 대용량 파일에는 비효율적입니다.

주요 사용처:

동적으로 생성된 파일:
이미지 생성 라이브러리(예: System.Drawing.Common, ImageSharp)로 런타임에 생성된 이미지.
데이터베이스에 저장된 파일:
파일 데이터가 BLOB(Binary Large Object) 형태로 데이터베이스에 저장되어 있으며, 이를 byte[]로 읽어와야 하는 경우.
작은 파일:
메모리 오버헤드가 무시할 만한 수준의 작은 파일.

생성자 매개변수:

byte[] fileContents: 전송할 파일의 바이트 배열 데이터.
string contentType: 파일의 MIME 타입 (예: “image/png”, “application/pdf”, “text/plain”).
string? fileDownloadName (선택 사항): 브라우저가 파일을 다운로드할 때 제안할 파일 이름.
이 매개변수를 지정하면 Content-Disposition 헤더가 attachment로 설정되어 브라우저가 파일을 인라인으로 표시하는 대신 다운로드하도록 유도합니다.

예시:

using Microsoft.AspNetCore.Mvc;
using System.Text;

public class DynamicFileController : Controller
{
    // GET: /DynamicFile/GenerateText
    public IActionResult GenerateText()
    {
        var content = "이것은 동적으로 생성된 텍스트 파일입니다. " +
                      "현재 시간: " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        byte[] fileBytes = Encoding.UTF8.GetBytes(content);

        return File(fileBytes, "text/plain", "generated_text.txt");
    }

    // GET: /DynamicFile/GetImageFromDatabase
    public IActionResult GetImageFromDatabase()
    {
        // 실제 시나리오에서는 DB에서 byte[]를 읽어옵니다.
        // 여기서는 예시를 위해 더미 바이트 배열을 사용합니다.
        byte[] imageBytes = new byte[] { /* ... PNG 이미지 바이트 데이터 ... */ };

        return File(imageBytes, "image/png", "db_image.png");
    }
}

VirtualFileResult

https://learn.microsoft.com/ko-kr/dotnet/api/microsoft.aspnetcore.mvc.virtualfileresult?view=aspnetcore-8.0

웹 애플리케이션의 가상 경로(Virtual Path)를 사용하여 파일을 제공할 때 사용됩니다.

ASP.NET Core는 이 가상 경로를 실제 파일 시스템 경로로 변환하여 파일을 찾아 클라이언트에 스트리밍합니다.

정의:
Microsoft.AspNetCore.Mvc.VirtualFileResult
데이터 원본:
웹 루트(wwwroot)를 기준으로 한 가상 경로
메모리 사용:
낮음. 파일의 내용이 메모리에 한 번에 로드되지 않고, 스트림 방식으로 전송되므로 대용량 파일에도 적합합니다.
성능:
효율적입니다.

주요 사용처:

wwwroot 내의 정적 파일: 애플리케이션의 wwwroot 폴더 내에 있는 CSS, JavaScript, 이미지 등 정적 파일을 컨트롤러 액션 메서드에서 직접 제공해야 할 때 (예: 특정 인증/권한이 필요한 정적 파일).
StaticFileOptions로 구성된 가상 경로: UseStaticFiles 미들웨어 구성 시 RequestPath를 지정하여 만든 가상 경로에 있는 파일.

생성자 매개변수:

string virtualPath: 웹 루트를 기준으로 한 가상 경로 (예: ~/images/logo.png, /css/site.css).
string contentType: 파일의 MIME 타입.
string? fileDownloadName (선택 사항): 다운로드 시 파일 이름.

예시:

using Microsoft.AspNetCore.Mvc;

public class StaticAssetController : Controller
{
    // GET: /StaticAsset/GetAppStyle
    public IActionResult GetAppStyle()
    {
        // wwwroot/css/app.css 파일을 제공합니다.
        return File("~/css/app.css", "text/css");
    }

    // GET: /StaticAsset/DownloadSampleDocument
    public IActionResult DownloadSampleDocument()
    {
        // wwwroot/downloads/sample.pdf 파일을 다운로드합니다.
        return File("/downloads/sample.pdf", "application/pdf", "SampleDocument.pdf");
    }
}

PhysicalFileResult

https://learn.microsoft.com/ko-kr/dotnet/api/microsoft.aspnetcore.mvc.physicalfileresult?view=aspnetcore-8.0

서버의 실제 파일 시스템 경로(Physical Path)를 사용하여 파일을 제공할 때 사용됩니다.

웹 애플리케이션의 루트 디렉토리를 벗어나 서버의 임의의 경로에 있는 파일을 제공해야 할 때 가장 유용합니다.

정의:
Microsoft.AspNetCore.Mvc.PhysicalFileResult
데이터 원본:
서버의 실제 파일 시스템 경로 (절대 경로 또는 콘텐츠 루트 기준 상대 경로)
메모리 사용:
낮음. VirtualFileResult와 마찬가지로 스트림 방식으로 전송되어 메모리 효율적입니다.
성능:
효율적입니다.

주요 사용처:

웹 루트 외부 파일: 사용자가 업로드한 파일, 백업 파일, 또는 보안상의 이유로 wwwroot에 직접 노출되지 않는 폴더에 저장된 파일.
서버의 특정 위치에 있는 파일: 애플리케이션과 독립적으로 관리되는 파일 저장소의 파일.

생성자 매개변수:

string physicalPath: 파일의 절대 경로 (예: “C:\Uploads\document.pdf”) 또는 애플리케이션의 콘텐츠 루트에 대한 상대 경로.
string contentType: 파일의 MIME 타입.
string? fileDownloadName (선택 사항): 다운로드 시 파일 이름.

주의사항: 사용자가 physicalPath를 직접 제어할 수 있는 경우 보안 취약점이 될 수 있습니다. 경로 유효성 검사 및 인가 처리가 필수적입니다.

예시:

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Hosting; // IWebHostEnvironment를 사용하기 위해 필요

public class UploadedFileController : Controller
{
    private readonly IWebHostEnvironment _env;

    public UploadedFileController(IWebHostEnvironment env)
    {
        _env = env;
    }

    // GET: /UploadedFile/Download/{fileName}
    public IActionResult Download(string fileName)
    {
        // 업로드된 파일이 ContentRootPath/UserUploads 폴더에 저장되어 있다고 가정합니다.
        var filePath = Path.Combine(_env.ContentRootPath, "UserUploads", fileName);

        if (!System.IO.File.Exists(filePath))
        {
            return NotFound();
        }

        // 파일 확장자를 기반으로 MIME 타입 결정 (실제로는 더 견고한 로직 필요)
        string contentType;
        var ext = Path.GetExtension(fileName).ToLowerInvariant();
        if (ext == ".pdf") contentType = "application/pdf";
        else if (ext == ".jpg" || ext == ".jpeg") contentType = "image/jpeg";
        else contentType = "application/octet-stream"; // 기본값: 알 수 없는 파일

        return PhysicalFile(filePath, contentType, fileName);
    }
}

FileStreamResult (스트림 기반 파일 Serving)

https://learn.microsoft.com/ko-kr/dotnet/api/microsoft.aspnetcore.mvc.filestreamresult?view=aspnetcore-8.0

FileStreamResult는 Stream 객체로부터 직접 파일을 제공할 때 사용됩니다.

이는 PhysicalFileResult나 VirtualFileResult와 마찬가지로 메모리 효율적이며,

파일이 이미 스트림 형태로 열려 있거나 외부 소스에서 스트림으로 직접 데이터를 읽어올 때 유용합니다.

정의:
Microsoft.AspNetCore.Mvc.FileStreamResult
데이터 원본:
System.IO.Stream
메모리 사용:
낮음. 파일 내용을 한 번에 메모리에 로드하지 않고 스트림에서 직접 읽어 전송합니다.
성능:
효율적입니다.

주요 사용처:

네트워크 스트림에서 직접 읽어온 데이터.
압축 파일 내부의 특정 파일을 스트림으로 추출하여 제공할 때.
데이터베이스에서 BLOB 데이터를 Stream으로 직접 가져올 때.
외부 API에서 스트림 형태로 응답을 받을 때.

생성자 매개변수:

Stream fileStream: 전송할 파일의 내용을 담고 있는 스트림.
string contentType: 파일의 MIME 타입.
string? fileDownloadName (선택 사항): 다운로드 시 파일 이름.

예시:

using Microsoft.AspNetCore.Mvc;
using System.IO;

public class StreamFileController : Controller
{
    // GET: /StreamFile/GetLogFile
    public IActionResult GetLogFile()
    {
        var logFilePath = Path.Combine(AppContext.BaseDirectory, "Logs", "application.log");
        if (!System.IO.File.Exists(logFilePath))
        {
            return NotFound();
        }
        // FileStream을 직접 열어 FileStreamResult로 반환
        var stream = new FileStream(logFilePath, FileMode.Open, FileAccess.Read);
        return File(stream, "text/plain", "application.log");
    }
}

2⃣ 파일 처리 관련 기타 핵심 인터페이스 및 개념

FileResult 유형 외에도 ASP.NET Core에서 파일을 효율적이고 안전하게 다루기 위해 알아야 할 중요한 인터페이스와 개념들이 있습니다.

IFormFile 및 IFormFileCollection (파일 업로드)

https://learn.microsoft.com/ko-kr/dotnet/api/microsoft.aspnetcore.http.iformfile?view=aspnetcore-8.0

https://learn.microsoft.com/ko-kr/dotnet/api/microsoft.aspnetcore.http.iformfilecollection?view=aspnetcore-8.0

클라이언트(브라우저)에서 서버로 파일을 전송할 때 사용하는 인터페이스입니다.

IFormFile: 단일 업로드 파일을 나타냅니다.
- 정의: Microsoft.AspNetCore.Http.IFormFile
- 주요 속성: FileName, ContentType, Length.
- 주요 메서드: CopyToAsync(Stream), OpenReadStream().
IFormFileCollection: 여러 개의 업로드 파일을 나타내는 IFormFile 객체의 컬렉션입니다.
- 정의: Microsoft.AspNetCore.Http.IFormFileCollection
- 사용 예시: 폼 요소로 여러 파일을 받을 때 컨트롤러 액션의 매개변수로 사용됩니다.

IWebHostEnvironment 및 IHostEnvironment (환경 정보 및 경로)

https://learn.microsoft.com/ko-kr/dotnet/api/microsoft.aspnetcore.hosting.iwebhostenvironment?view=aspnetcore-8.0

https://learn.microsoft.com/ko-kr/dotnet/api/microsoft.aspnetcore.components.routing.ihostenvironmentnavigationmanager?view=aspnetcore-8.0

애플리케이션의 호스팅 환경에 대한 정보를 제공하여, 파일 경로를 구성하고 접근할 때 매우 유용합니다. 이들은 DI 컨테이너에 등록되어 있어 생성자를 통해 쉽게 주입받을 수 있습니다.

IWebHostEnvironment: 웹 호스팅 환경에 특화된 정보를 제공합니다.
- 정의: Microsoft.AspNetCore.Hosting.IWebHostEnvironment
- 주요 속성:
  - WebRootPath: 웹 루트(wwwroot) 폴더의 물리적 경로. 정적 파일이 위치하는 곳입니다.
  - WebRootFileProvider: WebRootPath에 대한 IFileProvider 인스턴스.
- 주요 사용처: 정적 파일 저장 경로, 웹에 노출될 리소스 경로 구성.
IHostEnvironment: 일반적인 호스팅 환경 정보를 제공합니다. IWebHostEnvironment는 IHostEnvironment를 상속합니다.
- 정의: Microsoft.Extensions.Hosting.IHostEnvironment
- 주요 속성:
  - ContentRootPath: 애플리케이션의 콘텐츠 루트 폴더(프로젝트 파일이 있는 기본 디렉토리)의 물리적 경로.
  - ContentRootFileProvider: ContentRootPath에 대한 IFileProvider 인스턴스.
  - EnvironmentName: 현재 실행 중인 환경의 이름 (예: “Development”, “Production”, “Staging”).
- 주요 사용처: 로그 파일, 설정 파일 등 애플리케이션이 사용하는 비-웹 관련 파일 경로 구성.

IFileProvider (추상화된 파일 시스템 접근)

파일 시스템 접근을 추상화하는 핵심 인터페이스입니다.

물리적인 디스크, 메모리, 압축 파일 등 다양한 소스에서 파일을 일관된 방식으로 다룰 수 있게 해줍니다.

정의: Microsoft.Extensions.FileProviders.IFileProvider
주요 역할: 파일 존재 여부 확인, 디렉토리 내용 열거, 파일 내용 스트림 생성 등 파일 시스템 작업을 수행합니다. UseStaticFiles 미들웨어, Razor Pages 등에서 내부적으로 사용됩니다.
주요 메서드:
- GetFileInfo(string subpath): 지정된 하위 경로의 파일 또는 디렉토리에 대한 IFileInfo 객체를 반환합니다.
- GetDirectoryContents(string subpath): 지정된 하위 경로의 디렉토리 콘텐츠(IDirectoryContents)를 반환합니다.
- Watch(string filter): 지정된 필터와 일치하는 파일 또는 디렉토리의 변경 사항을 감시합니다 (예: 파일 변경 시 캐시 무효화).
주요 구현체:
- PhysicalFileProvider: 실제 파일 시스템 경로에서 파일을 제공합니다.
- CompositeFileProvider: 여러 IFileProvider를 결합하여 여러 위치에서 파일을 찾을 수 있게 합니다.

IFileInfo 및 IDirectoryContents (파일/디렉토리 메타데이터)

https://learn.microsoft.com/ko-kr/dotnet/api/microsoft.aspnetcore.mvc.razor.runtimecompilation.fileproviderrazorprojectitem.fileinfo?view=aspnetcore-8.0#microsoft-aspnetcore-mvc-razor-runtimecompilation-fileproviderrazorprojectitem-fileinfo

IFileProvider와 함께 사용되어 파일 시스템 항목의 상세 정보를 제공합니다.

IFileInfo: 단일 파일 또는 디렉토리에 대한 메타데이터 (이름, 크기, 수정 시간, 존재 여부 등)를 제공합니다. IFileProvider.GetFileInfo()가 반환합니다.
IDirectoryContents: 디렉토리 내의 파일 및 서브디렉토리 목록을 나타냅니다. IFileProvider.GetDirectoryContents()가 반환하며, IEnumerable를 구현합니다.

3⃣ 고급 파일 처리 기능

파일 업로드 보안 강화

파일 시그니처 검증

파일 확장자만으로는 안전하지 않으며, 파일 시그니처(매직 바이트) 검증이 필요합니다.

public static class FileSignatureValidator
{
    private static readonly Dictionary FileSignatures = new()
    {
        { ".jpg", new[] { new byte[] { 0xFF, 0xD8, 0xFF } } },
        { ".jpeg", new[] { new byte[] { 0xFF, 0xD8, 0xFF } } },
        { ".png", new[] { new byte[] { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A } } },
        { ".pdf", new[] { new byte[] { 0x25, 0x50, 0x44, 0x46 } } },
        { ".gif", new[] { new byte[] { 0x47, 0x49, 0x46, 0x38 } } }
    };

    public static bool IsValidFileSignature(IFormFile file, string[] allowedExtensions)
    {
        if (file.Length == 0) return false;

        var ext = Path.GetExtension(file.FileName).ToLowerInvariant();
        if (!allowedExtensions.Contains(ext) || !FileSignatures.ContainsKey(ext))
            return false;

        using var reader = new BinaryReader(file.OpenReadStream());
        var signatures = FileSignatures[ext];
        var headerBytes = reader.ReadBytes(signatures.Max(s => s.Length));

        return signatures.Any(signature => 
            headerBytes.Take(signature.Length).SequenceEqual(signature));
    }
}

커스텀 파일 검증 어트리뷰트

public class AllowedExtensionsAttribute : ValidationAttribute
{
    private readonly string[] _extensions;

    public AllowedExtensionsAttribute(params string[] extensions)
    {
        _extensions = extensions;
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        if (value is IFormFile file)
        {
            if (!FileSignatureValidator.IsValidFileSignature(file, _extensions))
            {
                return new ValidationResult("허용되지 않는 파일 형식입니다.");
            }
        }
        return ValidationResult.Success;
    }
}

public class MaxFileSizeAttribute : ValidationAttribute
{
    private readonly int _maxFileSize;

    public MaxFileSizeAttribute(int maxFileSize)
    {
        _maxFileSize = maxFileSize;
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        if (value is IFormFile file && file.Length > _maxFileSize)
        {
            return new ValidationResult($"파일 크기는 {_maxFileSize / (1024 * 1024)}MB를 초과할 수 없습니다.");
        }
        return ValidationResult.Success;
    }
}

// 사용 예시
public class FileUploadModel
{
    [AllowedExtensions(".jpg", ".jpeg", ".png", ".pdf")]
    [MaxFileSize(5 * 1024 * 1024)] // 5MB
    public IFormFile UploadedFile { get; set; }
}

대용량 파일 처리 최적화

스트리밍 업로드

[HttpPost]
[DisableFormValueModelBinding]
public async Task UploadLargeFile()
{
    if (!IsMultipartContentType(Request.ContentType))
        return BadRequest("지원하지 않는 미디어 타입입니다.");

    var boundary = GetBoundary(Request.ContentType);
    var reader = new MultipartReader(boundary, HttpContext.Request.Body);
    var section = await reader.ReadNextSectionAsync();

    while (section != null)
    {
        if (ContentDispositionHeaderValue.TryParse(section.ContentDisposition, 
            out var contentDisposition))
        {
            if (HasFileContentDisposition(contentDisposition))
            {
                var fileName = contentDisposition.FileName.Value;
                var filePath = Path.Combine("uploads", fileName);
                
                using var targetStream = new FileStream(filePath, FileMode.Create);
                await section.Body.CopyToAsync(targetStream);
            }
        }
        section = await reader.ReadNextSectionAsync();
    }

    return Ok("파일 업로드 완료");
}

private static bool IsMultipartContentType(string contentType)
{
    return !string.IsNullOrEmpty(contentType) 
           && contentType.IndexOf("multipart/", StringComparison.OrdinalIgnoreCase) >= 0;
}

private static string GetBoundary(string contentType)
{
    var elements = contentType.Split(' ');
    var element = elements.Where(entry => entry.StartsWith("boundary=")).First();
    var boundary = element.Substring("boundary=".Length);
    return HeaderUtilities.RemoveQuotes(boundary).Value;
}

private static bool HasFileContentDisposition(ContentDispositionHeaderValue contentDisposition)
{
    return contentDisposition != null
           && contentDisposition.DispositionType.Equals("form-data")
           && (!StringSegment.IsNullOrEmpty(contentDisposition.FileName)
               || !StringSegment.IsNullOrEmpty(contentDisposition.FileNameStar));
}

Range Request 지원 (부분 콘텐츠 전송)

public IActionResult DownloadWithRangeSupport(string fileName)
{
    var filePath = Path.Combine("uploads", fileName);
    if (!System.IO.File.Exists(filePath))
        return NotFound();

    var fileInfo = new FileInfo(filePath);
    var rangeHeader = Request.Headers["Range"].ToString();

    if (!string.IsNullOrEmpty(rangeHeader))
    {
        // Range 요청 처리
        var range = ParseRangeHeader(rangeHeader, fileInfo.Length);
        if (range.HasValue)
        {
            var (start, end) = range.Value;
            var contentLength = end - start + 1;

            Response.StatusCode = 206; // Partial Content
            Response.Headers.Add("Content-Range", $"bytes {start}-{end}/{fileInfo.Length}");
            Response.Headers.Add("Content-Length", contentLength.ToString());

            var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
            stream.Seek(start, SeekOrigin.Begin);
            
            return File(stream, "application/octet-stream", fileName, enableRangeProcessing: true);
        }
    }

    return PhysicalFile(filePath, "application/octet-stream", fileName);
}

private (long start, long end)? ParseRangeHeader(string rangeHeader, long fileLength)
{
    if (!rangeHeader.StartsWith("bytes="))
        return null;

    var range = rangeHeader.Substring(6);
    var parts = range.Split('-');
    
    if (parts.Length != 2)
        return null;

    long start = 0, end = fileLength - 1;

    if (!string.IsNullOrEmpty(parts[0]))
        start = long.Parse(parts[0]);

    if (!string.IsNullOrEmpty(parts[1]))
        end = long.Parse(parts[1]);

    if (start > end || start >= fileLength)
        return null;

    return (start, Math.Min(end, fileLength - 1));
}

임시 파일 관리 및 정리

임시 파일 자동 정리 서비스

public class TempFileCleanupService : BackgroundService
{
    private readonly ILogger _logger;
    private readonly string _tempDirectory;

    public TempFileCleanupService(ILogger logger, IWebHostEnvironment env)
    {
        _logger = logger;
        _tempDirectory = Path.Combine(env.ContentRootPath, "temp");
        
        // 임시 디렉토리가 존재하지 않으면 생성
        if (!Directory.Exists(_tempDirectory))
        {
            Directory.CreateDirectory(_tempDirectory);
        }
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                CleanupOldTempFiles();
                await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "임시 파일 삭제 실패: {FilePath}", file);
            }
        }
    }
}

// Program.cs에서 서비스 등록
builder.Services.AddHostedService();

파일 압축 및 최적화

이미지 자동 리사이징

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Jpeg;

public class ImageProcessingResult : FileStreamResult
{
    public ImageProcessingResult(Stream imageStream, string contentType, int maxWidth = 800, int maxHeight = 600)
        : base(ProcessImage(imageStream, maxWidth, maxHeight), contentType)
    {
    }

    private static Stream ProcessImage(Stream originalStream, int maxWidth, int maxHeight)
    {
        using var image = Image.Load(originalStream);
        
        if (image.Width > maxWidth || image.Height > maxHeight)
        {
            image.Mutate(x => x.Resize(new ResizeOptions
            {
                Size = new Size(maxWidth, maxHeight),
                Mode = ResizeMode.Max
            }));
        }

        var outputStream = new MemoryStream();
        image.SaveAsJpeg(outputStream, new JpegEncoder { Quality = 85 });
        outputStream.Position = 0;
        
        return outputStream;
    }
}

// 사용 예시
public IActionResult GetOptimizedImage(string fileName)
{
    var filePath = Path.Combine("images", fileName);
    if (!System.IO.File.Exists(filePath))
        return NotFound();
        
    var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
    
    return new ImageProcessingResult(stream, "image/jpeg");
}

파일 메타데이터 및 추적

파일 메타데이터 모델

public class FileMetadata
{
    public string Id { get; set; } = Guid.NewGuid().ToString();
    public string OriginalName { get; set; }
    public string StoredName { get; set; }
    public string ContentType { get; set; }
    public long Size { get; set; }
    public string Hash { get; set; } // SHA256 해시
    public DateTime UploadedAt { get; set; } = DateTime.UtcNow;
    public string UploadedBy { get; set; }
    public int DownloadCount { get; set; }
    public DateTime? LastAccessedAt { get; set; }
}

public class SecureFileService
{
    private readonly ILogger _logger;
    private readonly string _uploadDirectory;
    private readonly Dictionary _fileMetadata = new();

    public SecureFileService(ILogger logger, IWebHostEnvironment env)
    {
        _logger = logger;
        _uploadDirectory = Path.Combine(env.ContentRootPath, "SecureUploads");
        
        if (!Directory.Exists(_uploadDirectory))
        {
            Directory.CreateDirectory(_uploadDirectory);
        }
    }

    public async Task SaveFileAsync(IFormFile file, string userId)
    {
        // 파일 시그니처 검증
        var allowedExtensions = new[] { ".jpg", ".jpeg", ".png", ".pdf", ".docx", ".xlsx" };
        if (!FileSignatureValidator.IsValidFileSignature(file, allowedExtensions))
        {
            throw new InvalidOperationException("허용되지 않는 파일 형식입니다.");
        }

        var metadata = new FileMetadata
        {
            OriginalName = file.FileName,
            StoredName = $"{Guid.NewGuid()}{Path.GetExtension(file.FileName)}",
            ContentType = file.ContentType,
            Size = file.Length,
            UploadedBy = userId
        };

        var filePath = Path.Combine(_uploadDirectory, metadata.StoredName);
        
        // 파일 저장
        using (var stream = new FileStream(filePath, FileMode.Create))
        {
            await file.CopyToAsync(stream);
        }

        // 파일 해시 계산
        metadata.Hash = await ComputeFileHashAsync(filePath);
        
        // 메타데이터 저장
        _fileMetadata[metadata.Id] = metadata;
        
        _logger.LogInformation("파일 저장 완료: {FileName} ({FileId})", 
            metadata.OriginalName, metadata.Id);
        
        return metadata;
    }

    public async Task<(Stream stream, FileMetadata metadata)> GetFileAsync(string fileId)
    {
        if (!_fileMetadata.TryGetValue(fileId, out var metadata))
        {
            throw new FileNotFoundException("파일을 찾을 수 없습니다.");
        }

        var filePath = Path.Combine(_uploadDirectory, metadata.StoredName);
        if (!System.IO.File.Exists(filePath))
        {
            throw new FileNotFoundException("물리적 파일이 존재하지 않습니다.");
        }

        // 다운로드 통계 업데이트
        metadata.DownloadCount++;
        metadata.LastAccessedAt = DateTime.UtcNow;

        var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
        return (stream, metadata);
    }

    private async Task ComputeFileHashAsync(string filePath)
    {
        using var sha256 = SHA256.Create();
        using var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
        var hash = await sha256.ComputeHashAsync(stream);
        return Convert.ToBase64String(hash);
    }

    public bool DeleteFile(string fileId, string userId)
    {
        if (!_fileMetadata.TryGetValue(fileId, out var metadata))
        {
            return false;
        }

        // 권한 확인
        if (metadata.UploadedBy != userId)
        {
            throw new UnauthorizedAccessException("파일 삭제 권한이 없습니다.");
        }

        var filePath = Path.Combine(_uploadDirectory, metadata.StoredName);
        
        try
        {
            if (System.IO.File.Exists(filePath))
            {
                System.IO.File.Delete(filePath);
            }
            
            _fileMetadata.Remove(fileId);
            
            _logger.LogInformation("파일 삭제 완료: {FileName} ({FileId})", 
                metadata.OriginalName, fileId);
            
            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "파일 삭제 실패: {FileName} ({FileId})", 
                metadata.OriginalName, fileId);
            return false;
        }
    }
}

에러 처리 및 로깅

포괄적인 파일 에러 처리

public class FileController : Controller
{
    private readonly ILogger _logger;
    private readonly SecureFileService _fileService;

    public FileController(ILogger logger, SecureFileService fileService)
    {
        _logger = logger;
        _fileService = fileService;
    }

    [HttpPost]
    public async Task Upload(IFormFile file)
    {
        try
        {
            if (file == null || file.Length == 0)
                return BadRequest(new { error = "파일이 선택되지 않았습니다." });

            if (file.Length > 10 * 1024 * 1024) // 10MB
                return BadRequest(new { error = "파일 크기가 10MB를 초과합니다." });

            // 파일명 검증 (경로 조작 공격 방지)
            var fileName = Path.GetFileName(file.FileName);
            if (string.IsNullOrEmpty(fileName) || fileName.Contains(".."))
                return BadRequest(new { error = "유효하지 않은 파일명입니다." });

            var result = await _fileService.SaveFileAsync(file, User.Identity.Name);
            
            _logger.LogInformation("파일 업로드 성공: {FileName}, 사용자: {User}, 파일ID: {FileId}", 
                file.FileName, User.Identity.Name, result.Id);

            return Ok(new { 
                fileId = result.Id, 
                fileName = result.OriginalName,
                size = result.Size,
                message = "파일 업로드 완료" 
            });
        }
        catch (InvalidOperationException ex)
        {
            _logger.LogWarning("파일 업로드 유효성 검사 실패: {FileName}, 오류: {Error}", 
                file?.FileName, ex.Message);
            return BadRequest(new { error = ex.Message });
        }
        catch (IOException ex)
        {
            _logger.LogError(ex, "파일 I/O 오류: {FileName}", file?.FileName);
            return StatusCode(500, new { error = "파일 저장 중 오류가 발생했습니다." });
        }
        catch (UnauthorizedAccessException ex)
        {
            _logger.LogError(ex, "파일 접근 권한 오류: {FileName}", file?.FileName);
            return StatusCode(500, new { error = "파일 접근 권한이 없습니다." });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "예상치 못한 오류: {FileName}", file?.FileName);
            return StatusCode(500, new { error = "파일 처리 중 오류가 발생했습니다." });
        }
    }

    [HttpGet("{fileId}")]
    public async Task Download(string fileId)
    {
        try
        {
            var (stream, metadata) = await _fileService.GetFileAsync(fileId);
            
            _logger.LogInformation("파일 다운로드: {FileName} ({FileId}), 사용자: {User}", 
                metadata.OriginalName, fileId, User.Identity.Name);

            return File(stream, metadata.ContentType, metadata.OriginalName);
        }
        catch (FileNotFoundException ex)
        {
            _logger.LogWarning("파일 다운로드 실패 - 파일 없음: {FileId}, 사용자: {User}", 
                fileId, User.Identity.Name);
            return NotFound(new { error = "파일을 찾을 수 없습니다." });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "파일 다운로드 오류: {FileId}", fileId);
            return StatusCode(500, new { error = "파일 다운로드 중 오류가 발생했습니다." });
        }
    }

    [HttpDelete("{fileId}")]
    public IActionResult Delete(string fileId)
    {
        try
        {
            var success = _fileService.DeleteFile(fileId, User.Identity.Name);
            
            if (!success)
                return NotFound(new { error = "파일을 찾을 수 없습니다." });

            return Ok(new { message = "파일이 삭제되었습니다." });
        }
        catch (UnauthorizedAccessException ex)
        {
            _logger.LogWarning("파일 삭제 권한 없음: {FileId}, 사용자: {User}", 
                fileId, User.Identity.Name);
            return Forbid("파일 삭제 권한이 없습니다.");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "파일 삭제 오류: {FileId}", fileId);
            return StatusCode(500, new { error = "파일 삭제 중 오류가 발생했습니다." });
        }
    }
}

4⃣ 파일 처리 시 보안 및 성능 고려사항

보안 고려사항

경로 유효성 검사:
PhysicalFileResult나 파일 업로드 시 사용자가 제공한 파일 이름/경로에 대해 경로 조작(Path Traversal) 공격을 방지하기 위해 철저한 유효성 검사를 수행해야 합니다.
Path.GetFullPath(), Path.GetFileName() 등을 사용하여 안전한 경로를 구성하고, 허용된 디렉토리 내에만 파일을 저장하도록 제한해야 합니다.
MIME 타입:
올바른 Content-Type을 지정하여 브라우저가 파일을 올바르게 해석하고, 잠재적인 스크립트 실행 공격을 방지합니다.
FileExtensionContentTypeProvider와 같은 클래스를 사용하여 MIME 타입을 자동으로 추론하는 것이 좋습니다.
파일 시그니처 검증:
파일 확장자만으로는 안전하지 않으므로, 파일의 매직 바이트(시그니처)를 검증하여 실제 파일 형식을 확인해야 합니다.
파일 크기 제한:
서비스 거부 공격을 방지하기 위해 업로드 파일 크기를 제한해야 합니다.
바이러스 스캔:
중요한 시스템에서는 업로드된 파일에 대한 바이러스 검사를 수행해야 합니다.

성능 고려사항

대용량 파일:
큰 파일은 byte[]로 메모리에 로드하는 FileContentResult 대신, 스트림 기반의 VirtualFileResult, PhysicalFileResult, FileStreamResult를 사용하여 메모리 사용량을 최소화해야 합니다.
캐싱:
UseStaticFiles 미들웨어의 StaticFileOptions.OnPrepareResponse를 사용하여 Cache-Control 헤더를 설정하거나, ResponseCaching 미들웨어를 사용하여 캐싱 전략을 최적화할 수 있습니다.
응답 압축:
UseResponseCompression 미들웨어를 사용하여 정적 파일 및 동적 응답을 gzip, brotli 등으로 압축하여 네트워크 대역폭 사용을 줄이고 로딩 속도를 향상시킬 수 있습니다.
스트리밍 처리:
대용량 파일 업로드/다운로드 시 전체 파일을 메모리에 로드하지 않고 스트림으로 처리하여 메모리 효율성을 높입니다.
비동기 처리:
파일 I/O 작업은 항상 비동기 메서드(CopyToAsync, ReadAsync 등)를 사용하여 스레드 풀을 효율적으로 활용합니다.

5⃣ 프로덕션 환경 설정

Program.cs 설정 예시

var builder = WebApplication.CreateBuilder(args);

// 서비스 등록
builder.Services.AddControllers();
builder.Services.AddScoped();
builder.Services.AddHostedService();

// 파일 업로드 설정
builder.Services.Configure(options =>
{
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024; // 100MB
    options.ValueLengthLimit = int.MaxValue;
    options.ValueCountLimit = int.MaxValue;
    options.KeyLengthLimit = int.MaxValue;
});

// 응답 압축 설정
builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true;
    options.Providers.Add();
    options.Providers.Add();
});

var app = builder.Build();

// 미들웨어 파이프라인
app.UseResponseCompression();
app.UseStaticFiles(new StaticFileOptions
{
    OnPrepareResponse = ctx =>
    {
        // 정적 파일 캐싱 설정
        ctx.Context.Response.Headers.Append("Cache-Control", "public,max-age=31536000");
    }
});

app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();

app.Run();

로깅 설정 (appsettings.json)

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "FileController": "Information",
      "SecureFileService": "Information",
      "TempFileCleanupService": "Information"
    }
  }
}

6⃣ 결론

ASP.NET Core의 이러한 다양한 파일 처리 도구와 개념을 이해하고 적절히 활용하는 것은 견고하고 효율적인 웹 애플리케이션을 구축하는 데 필수적입니다.

특히 보안, 성능, 사용자 경험을 모두 고려한 파일 처리 시스템을 구축하기 위해서는:

적절한 FileResult 선택: 파일의 특성과 사용 목적에 따라 최적의 FileResult 유형을 선택
강력한 보안 검증: 파일 시그니처 검증, 경로 조작 방지, 크기 제한 등 다층적 보안 적용
성능 최적화: 스트리밍 처리, 캐싱, 압축 등을 통한 성능 향상
포괄적인 에러 처리: 예상 가능한 모든 오류 상황에 대한 적절한 처리와 로깅
사용자 경험 고려: Range Request 지원, 진행률 표시, 적절한 피드백 제공

이러한 원칙들을 따라 구현하면 안전하고 효율적이며 사용자 친화적인 파일 처리 시스템을 구축할 수 있습니다.

The post ASP.NET Core 파일 처리: FileResult 및 인터페이스 appeared first on 어제와 내일의 나 그 사이의 이야기.

Dependency Inversion Principle(DIP, 의존성 역전 원리)

lycos7560 — Sun, 03 Nov 2024 07:48:04 +0000

Dependency Inversion Principle(DIP, 의존성 역전 원리)

https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/architectural-principles#dependency-inversion

The direction of dependency within the application should be in the direction of abstraction, not implementation details.
애플리케이션 내의 종속성 방향은 구현 세부 사항이 아닌 추상화 방향이어야 합니다.
Most applications are written such that compile-time dependency flows in the direction of runtime execution, producing a direct dependency graph.
대부분의 애플리케이션은 컴파일 타임 종속성이 런타임 실행 방향으로 흐르도록 작성되어 직접적인 종속성 그래프를 생성합니다.

That is, if class A calls a method of class B and class B calls a method of class C, then at compile time class A will depend on class B, and class B will depend on class C.
즉, class A가 class B의 메서드를 호출하고 class B가 class C의 메서드를 호출하는 경우 컴파일 타임에 class A는 class B에 종속되고 class B는 class C에 종속됩니다.

코드 구조에서 세부 구현 내용에 의존하지 말고, 더 추상적이고 일반적인 개념에 의존해야 한다는 뜻
이렇게 하면 코드가 더 유연해지고, 변경하기 쉽고, 재사용하기도 쉬워진다.
예를 들어, 어떤 기능을 직접 호출하는 것보다 그 기능을 일반적으로 설명하는 인터페이스를 사용하는 것이 더 좋다는 의미)

Direct dependency graph.

Applying the dependency inversion principle allows A to call methods on an abstraction that B implements, making it possible for A to call B at run time, but for B to depend on an interface controlled by A at compile time (thus, inverting the typical compile-time dependency).
종속성 반전 원칙을 적용하면 A가 B가 구현하는 추상화에 대한 메서드를 호출할 수 있으므로 A가 런타임에 B를 호출할 수 있지만 B는 컴파일 타임에 A에 의해 제어되는 인터페이스에 의존할 수 있습니다
(따라서 일반적인 컴파일 타임 종속성을 반전시킵니다).

At run time, the flow of program execution remains unchanged, but the introduction of interfaces means that different implementations of these interfaces can easily be plugged in.
런타임에 프로그램 실행의 흐름은 변경되지 않지만 인터페이스의 도입은 이러한 인터페이스의 다른 구현을 쉽게 연결할 수 있음을 의미합니다.

Inverted dependency graph.

Dependency inversion is a key part of building loosely coupled applications, since implementation details can be written to depend on and implement higher-level abstractions, rather than the other way around.
종속성 반전은 느슨하게 결합된 애플리케이션을 구축하는 데 있어 중요한 부분인데, 그 이유는 구현 세부 정보를 작성하여 더 높은 수준의 추상화에 의존하고 구현하도록 할 수 있기 때문입니다.

The resulting applications are more testable, modular, and maintainable as a result.
그 결과 응용 프로그램은 더 쉽게 테스트할 수 있고, 모듈화되며, 유지 관리가 더 용이합니다.

The practice of dependency injection is made possible by following the dependency inversion principle.
종속성 주입의 연습은 종속성 반전 원칙을 따름으로써 가능합니다.

애플리케이션의 의존성을 구체적인 구현이 아니라 추상화된 개념에 맞추는 것

대부분의 애플리케이션은 A 클래스가 B 클래스를, B 클래스가 C 클래스를 호출하는 형태로 작성됩니다.

이는 A가 B에, B가 C에 의존하게 만든다는 뜻입니다. 종속성 반전 원칙을 적용하면 A는 B의 구체적인 구현이 아니라 B가 구현하는 추상 개념에 의존하게 됩니다.

이렇게 하면 코드를 더 쉽게 테스트할 수 있고, 변경 및 유지보수가 용이해집니다.

간단히 말해, 코드를 유연하고 재사용 가능하게 만들어줍니다.

종속성 반전 적용 전

// 엔진 클래스
public class Engine
{
    public void Start()
    {
        Console.WriteLine("Engine starts.");
    }
}

// 자동차 클래스
public class Car
{
    private Engine _engine = new Engine();

    public void Start()
    {
        _engine.Start();
        Console.WriteLine("Car starts.");
    }
}

// 메인 프로그램
public class Program
{
    public static void Main(string[] args)
    {
        Car car = new Car();
        car.Start();
    }
}

종속성 반전 적용 후

// 인터페이스 정의
public interface IEngine
{
    void Start();
}

// 엔진 클래스
public class Engine : IEngine
{
    public void Start()
    {
        Console.WriteLine("Engine starts.");
    }
}

// 전기 엔진 클래스
public class ElectricEngine : IEngine
{
    public void Start()
    {
        Console.WriteLine("Electric engine starts.");
    }
}

// 자동차 클래스
public class Car
{
    private IEngine _engine;

    public Car(IEngine engine)
    {
        _engine = engine;
    }

    public void Start()
    {
        _engine.Start();
        Console.WriteLine("Car starts.");
    }
}

// 메인 프로그램
public class Program
{
    public static void Main(string[] args)
    {
        IEngine engine = new Engine();
        Car car = new Car(engine);
        car.Start();
        
        IEngine electricEngine = new ElectricEngine();
        Car electricCar = new Car(electricEngine);
        electricCar.Start();
    }
}

The post Dependency Inversion Principle(DIP, 의존성 역전 원리) appeared first on 어제와 내일의 나 그 사이의 이야기.

Deploying ASP.NET Web API To Azure

lycos7560 — Fri, 01 Nov 2024 08:08:45 +0000

Deploying ASP.NET Web API To Azure

https://azure.microsoft.com/ko-kr

Azure 계정확인

위와 같은 작업 반복

계정 생성

The post Deploying ASP.NET Web API To Azure appeared first on 어제와 내일의 나 그 사이의 이야기.

Consuming REST Web APIs

lycos7560 — Thu, 31 Oct 2024 09:56:32 +0000

Consuming REST Web APIs

Consuming REST Web APIs

1. 프로젝트 생성(MVC UI)

ASP.Net Core Web App (MVC)

여러 개의 시작 프로젝트로 변경

MVC UI와 API(Swagger)

2. GET Controller 생성

HttpClient 적용

.Net에서 제공하는 HttpClient Class

https://learn.microsoft.com/ko-kr/dotnet/api/system.net.http.httpclient?view=net-8.0

HTTP 요청을 보내고 URI로 식별된 리소스에서 HTTP 응답을 수신하기 위한 클래스를 제공합니다.

public class HttpClient : System.Net.Http.HttpMessageInvoker

사용 예제

// HttpClient는 매번 사용될 때마다 인스턴스화되지 않고, 애플리케이션 전체에서 한 번만 인스턴스화되어야 합니다. 참고 사항을 참조하세요.
static readonly HttpClient client = new HttpClient();

static async Task Main()
{
    // 비동기 네트워크 메서드를 try/catch 블록 내에서 호출하여 예외를 처리합니다.
    try
    {
        // 비동기적으로 GET 요청을 보냅니다.
        using HttpResponseMessage response = await client.GetAsync("http://www.contoso.com/");
        
        // 요청이 성공적으로 완료되었는지 확인합니다.
        response.EnsureSuccessStatusCode();
        
        // 응답 본문을 문자열로 읽어옵니다.
        string responseBody = await response.Content.ReadAsStringAsync();
        
        // 위의 세 줄은 아래 새로운 헬퍼 메서드로 대체할 수 있습니다.
        // string responseBody = await client.GetStringAsync(uri);
        
        // 응답 본문을 콘솔에 출력합니다.
        Console.WriteLine(responseBody);
    }
    catch (HttpRequestException e)
    {
        // 예외가 발생했을 때 예외 메시지를 콘솔에 출력합니다.
        Console.WriteLine("\nException Caught!");
        Console.WriteLine("Message :{0} ", e.Message);
    }
}

HttpClient를 사용하려면, Program.cs 파일에 HttpClient Factory를 설정

이를 통해 효율적으로 HttpClient 인스턴스를 관리하고, 특히 성능 문제를 해결할 수 있음

Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

// HttpClient 삽입
builder.Services.AddHttpClient();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

NZWalks.API의 launchSettings.json

RegionsController의 GetAll Api를 사용

테스트를 위해서 인증 주석

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        // Index 액션 메서드
        public async Task Index()
        {
            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();
                
                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");
                
                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();
                
                // 응답 본문을 문자열로 읽어옴
                var stringResponse = await httpResponseMessage.Content.ReadAsStringAsync();
                
                // 응답 내용을 ViewBag에 저장
                ViewBag.Response = stringResponse;
                
                // 응답 메시지를 반환
                return Ok(httpResponseMessage);
            }
            catch (Exception ex)
            {
                // 예외를 로깅 (로그 기록)
            }
            
            // View를 반환
            return View();
        }
    }
}

3. Index.cshtml , _Layout.cshtml 생성 및 수정

Index.cshtml

@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}

Regions

@if (ViewBag.Respose is not null)
{
    ViewBag.Respose
}

_Layout.cshtml




    
    
    @ViewData["Title"] - NZWalksUI
    
    
    


    
        
            
                NZWalksUI
                
                
                    
                        
                            Home
                        
                        
                            Privacy
                        
                        
                            Regions
                        
                    
                
            
        
    
    
        
            @RenderBody()
        
    

    
        
            © 2024 - NZWalksUI - Privacy
        
    
    
    
    
    @await RenderSectionAsync("Scripts", required: false)

폴더 이름 수정

break point

API 적용 확인

4. RegionDto.cs 생성 및 Index.cshtml 적용

RegionDto.cs

namespace NZWalksUI.Models.DTO
{
    public class RegionDto
    {
        public Guid Id { get; set; }
        public string Code { get; set; }
        public string Name { get; set; }
        public string? RegionImageUrl { get; set; } // Nullable
    }
}

Index.cshtml

@model IEnumerable 

@* MVC를 빈 프로젝트에 대해 활성화하는 방법에 대한 추가 정보는 https://go.microsoft.com/fwlink/?LinkID=397860를 참조 *@

@{} 

Regions
 


        @foreach (var walk in Model) 
        {
            
        }
    
    
        
            Id  
            Code  
            Name  
        
    
    
                @walk.Id  
                @walk.Code  
                @walk.Name

Id	Code	Name
@walk.Id	@walk.Code	@walk.Name

5. POST Method 생성

Index.cshtml 수정

@model IEnumerable
@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}

Regions


    Add Region




        @foreach (var walk in Model)
        {
            
        }
    
    
        
            Id
            Code
            Name
        
    
    
                @walk.Id
                @walk.Code
                @walk.Name

Id	Code	Name
@walk.Id	@walk.Code	@walk.Name

AddRegionViewModel.cs 생성

namespace NZWalksUI.Models
{
    public class AddRegionViewModel
    {
        public string Code { get; set; }
        public string Name { get; set; }
        public string RegionImageUrl { get; set; }
    }
}

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;
using NZWalksUI.Models;
using NZWalksUI.Models.DTO;
using System.Net.Http;
using System.Text;
using System.Text.Json;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        [HttpGet]
        // Index 액션 메서드
        public async Task Index()
        {
            List response = new List();
            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();

                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");

                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();

                // 응답 본문을 JSON으로 읽어와 리스트에 추가
                response.AddRange(await httpResponseMessage.Content.ReadFromJsonAsync>());
            }
            catch (HttpRequestException e)
            {
                // 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"Request error: {e.Message}");
            }
            catch (Exception ex)
            {
                // 기타 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"An error occurred: {ex.Message}");
            }

            // View를 반환
            return View(response);
        }

        [HttpGet]
        public IActionResult Add()
        {
            return View(); // Add View 반환
        }

        [HttpPost]
        public async Task Add(AddRegionViewModel model)
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Post,
                RequestUri = new Uri("https://localhost:7256/api/regions"),
                Content = new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json") // JSON 요청 본문 설정
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode(); // 요청이 성공적으로 완료되었는지 확인

            var response = await httpResponseMessage.Content.ReadFromJsonAsync();

            if (response is not null)
            {
                return RedirectToAction("Index", "Regions"); // Index 액션으로 리디렉션
            }

            return View(); // View 반환
        }
    }
}

Add.cshtml

@model NZWalksUI.Models.AddRegionViewModel;

@*
*@

@{
}

Add Region



    
        Code
        
    

    
        Name
        
    

    
        Image URL

6. 단일 편집 기능

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;
using NZWalksUI.Models;
using NZWalksUI.Models.DTO;
using System.Net.Http;
using System.Text;
using System.Text.Json;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        [HttpGet]
        // Index 액션 메서드
        public async Task Index()
        {
            List response = new List();


            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();

                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");
               

                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();

                // // 응답 본문을 문자열로 읽어옴
                // var stringResponse = await httpResponseMessage.Content.ReadAsStringAsync();


                response.AddRange(await httpResponseMessage.Content.ReadFromJsonAsync>());

            }
            catch (HttpRequestException e)
            {
                // 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"Request error: {e.Message}");
            }
            catch (Exception ex)
            {
                // 기타 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"An error occurred: {ex.Message}");
            }

            // View를 반환
            return View(response);
        }

        [HttpGet]
        public IActionResult Add()
        { 
            return View();
        }

        [HttpPost]
        public async Task Add(AddRegionViewModel model)
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Post,
                RequestUri = new Uri("https://localhost:7256/api/regions"),
                Content = new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync();

            if (respose is not null)
            {
                return RedirectToAction("Index", "Regions");
            }

            return View();
        }

        [HttpGet]
        public async Task Edit(Guid id)
        {
            ViewBag.Id = id;
            return View();
        
        }
    }
}

Edite View 생성

Edit.cshtml

@* For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860 *@ @{ }

Edit Region

@ViewBag.Id

Index.cshtml 수정

@model IEnumerable
@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}

Regions


    Add Region




        @foreach (var walk in Model)
        {
            
        }
    
    
        
            Id
            Code
            Name
             
        
    
    
                @walk.Id
                @walk.Code
                @walk.Name
                
                    Eidt

Id	Code	Name
@walk.Id	@walk.Code	@walk.Name	Eidt

Error.cshtml 수정

@model NZWalksUI.Models.DTO.RegionDto

@{
}

Edit Region

@if (Model is not null)
{
    
        
            Id
            
        
        
            Code
            
        

        
            Name
            
        

        
            Image URL
            
        

        
            
        

    
}

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;
using NZWalksUI.Models;
using NZWalksUI.Models.DTO;
using System.Net.Http;
using System.Reflection;
using System.Text;
using System.Text.Json;
using static System.Net.WebRequestMethods;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        [HttpGet]
        // Index 액션 메서드
        public async Task Index()
        {
            List response = new List();


            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();

                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");
               

                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();

                // // 응답 본문을 문자열로 읽어옴
                // var stringResponse = await httpResponseMessage.Content.ReadAsStringAsync();


                response.AddRange(await httpResponseMessage.Content.ReadFromJsonAsync>());

            }
            catch (HttpRequestException e)
            {
                // 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"Request error: {e.Message}");
            }
            catch (Exception ex)
            {
                // 기타 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"An error occurred: {ex.Message}");
            }

            // View를 반환
            return View(response);
        }

        [HttpGet]
        public IActionResult Add()
        { 
            return View();
        }

        [HttpPost]
        public async Task Add(AddRegionViewModel model)
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Post,
                RequestUri = new Uri("https://localhost:7256/api/regions"),
                Content = new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync();

            if (respose is not null)
            {
                return RedirectToAction("Index", "Regions");
            }

            return View();
        }

        [HttpGet]
        public async Task Edit(Guid id)
        {
            var client = httpClientFactory.CreateClient();

            var response = await client.GetFromJsonAsync($"https://localhost:7256/api/regions/{id.ToString()}");

            if (response is not null) 
            { 
                return View(response);
            }

            return View(null);
        
        }

        [HttpPost]
        public async Task Edit(RegionDto request) 
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Put,
                RequestUri = new Uri($"https://localhost:7256/api/regions/{request.Id}"),
                Content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync();

            if (respose is not null)
            {
                return RedirectToAction("Edit", "Regions");
            }

            return View();
        }

    }
}

7. 삭제 기능

Edit.cshtml 수정

@model NZWalksUI.Models.DTO.RegionDto

@{
}

Edit Region

@if (Model is not null)
{
    
        
            Id
            
        
        
            Code
            
        

        
            Name
            
        

        
            Image URL
            
        

        
            
            
        

    
}

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;
using NZWalksUI.Models;
using NZWalksUI.Models.DTO;
using System.Text;
using System.Text.Json;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        [HttpGet]
        // Index 액션 메서드
        public async Task Index()
        {
            List response = new List();


            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();

                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");
               

                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();

                // // 응답 본문을 문자열로 읽어옴
                // var stringResponse = await httpResponseMessage.Content.ReadAsStringAsync();


                response.AddRange(await httpResponseMessage.Content.ReadFromJsonAsync>());

            }
            catch (HttpRequestException e)
            {
                // 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"Request error: {e.Message}");
            }
            catch (Exception ex)
            {
                // 기타 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"An error occurred: {ex.Message}");
            }

            // View를 반환
            return View(response);
        }

        [HttpGet]
        public IActionResult Add()
        { 
            return View();
        }

        [HttpPost]
        public async Task Add(AddRegionViewModel model)
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Post,
                RequestUri = new Uri("https://localhost:7256/api/regions"),
                Content = new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync();

            if (respose is not null)
            {
                return RedirectToAction("Index", "Regions");
            }

            return View();
        }

        [HttpGet]
        public async Task Edit(Guid id)
        {
            var client = httpClientFactory.CreateClient();

            var response = await client.GetFromJsonAsync($"https://localhost:7256/api/regions/{id.ToString()}");

            if (response is not null) 
            { 
                return View(response);
            }

            return View(null);
        
        }

        [HttpPost]
        public async Task Edit(RegionDto request) 
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Put,
                RequestUri = new Uri($"https://localhost:7256/api/regions/{request.Id}"),
                Content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync();

            if (respose is not null)
            {
                return RedirectToAction("Edit", "Regions");
            }

            return View();
        }

        [HttpPost]
        public async Task Delete(RegionDto request)
        {
            try 
            {
                var client = httpClientFactory.CreateClient();

                var httpResponseMessage = await client.DeleteAsync($"https://localhost:7256/api/regions/{request.Id}");
                httpResponseMessage.EnsureSuccessStatusCode();

                return RedirectToAction("Index", "Regions");

            }
            catch (Exception ex) 
            { 
            
            }

            return View("Edit");
        }

    }
}

The post Consuming REST Web APIs appeared first on 어제와 내일의 나 그 사이의 이야기.

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

Docker 백그라운드 실행 명령어

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

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

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

4. 기타 유용한 명령어

Docker Port Mapping(포트 매핑)

Docker 포트 매핑 (Port Mapping)

포트 매핑 왜 필요한가?

포트 매핑의 역할

간단한 예시

요약

Docker에서 HTML 페이지 배포

Docker에서 HTML 페이지 배포

웹 서버 nginx 이미지 가져오기

index.html 파일을 준비

HTML 테스트 페이지

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

Dockerfile 생성

Dockerfile 이미지 생성

컨테이너를 생성 및 실행

기본적인 Docker 명령어 연습

기본적인 Docker 명령어

.NET Image 추가

Docker / Virtual Machine 차이점

1. 아키텍처 비교

1.1 Virtual Machine 아키텍처

1.2 Docker 아키텍처

2. 핵심 차이점 분석

2.1 운영체제 레이어

2.2 리소스 사용량

Virtual Machine

Docker

2.3 성능 비교

3. 장단점 비교

3.1 Virtual Machine

장점

단점

3.2 Docker

장점

단점

4. 사용 사례별 권장사항

4.1 Virtual Machine이 적합한 경우

4.2 Docker가 적합한 경우

5. 하이브리드 접근법

5.1 VM 위의 Docker

5.2 클라우드 환경

6. 결론

ASP.NET Core – UseStaticFiles

UseStaticFiles

1⃣ UseStaticFiles 미들웨어의 개념

2⃣ UseStaticFiles의 주요 역할

3⃣ UseStaticFiles 사용 방법

기본 사용법 (wwwroot 폴더)

다른 폴더의 정적 파일 제공

디렉터리 브라우징 활성화 (권장하지 않음)

4⃣ UseStaticFiles 미들웨어의 위치

ASP.NET Core 파일 처리: FileResult 및 인터페이스

ASP.NET Core 파일 처리: FileResult 및 인터페이스

1⃣ File Download 및 Serving을 위한 FileResult 유형

FileContentResult

VirtualFileResult

PhysicalFileResult

FileStreamResult (스트림 기반 파일 Serving)

2⃣ 파일 처리 관련 기타 핵심 인터페이스 및 개념

IFormFile 및 IFormFileCollection (파일 업로드)

IWebHostEnvironment 및 IHostEnvironment (환경 정보 및 경로)

IFileProvider (추상화된 파일 시스템 접근)

IFileInfo 및 IDirectoryContents (파일/디렉토리 메타데이터)

3⃣ 고급 파일 처리 기능

파일 업로드 보안 강화

파일 시그니처 검증

커스텀 파일 검증 어트리뷰트

대용량 파일 처리 최적화

스트리밍 업로드

Range Request 지원 (부분 콘텐츠 전송)

임시 파일 관리 및 정리

임시 파일 자동 정리 서비스

파일 압축 및 최적화

이미지 자동 리사이징

4⃣ `UseStaticFiles` 미들웨어의 위치