[ASP.NET Core] Clean Architecture 로 인증, 인가(JWT) 서비스 개발

1. 개요

Spring Boot로 웹 개발만 하다가 c# 으로 할 수도..? 있게 됐는데 c# 이나 .asp.net core 관련해선 국내 자료가 진짜 너어어어무 없다. 

 

객체지향, DI 등 Spring Boot와 굉장히 유사하다고는 하지만 보고 배울 자료들이 너무 부족하다는걸 느꼈다. 새삼 Java 생태계가 크구나 라는 생각이 들었다..

 

 

그래서 c# 공부를 하며 배운 내용을 공유하고자 글을 쓴다. 

 

 

원래라면 프로젝트 구성하는 내용 따윈(?) 블로그에 절대 쓰지 않지만, Java, Spring Boot 만 하던 나에게 c#은 시작 조차 어려웠기 때문에 상세하게 기록하도록 하겠다.

 

 

 

 

 

 

 

 

 

 

 

 

2. Clean Architecture란?

 

클린 아키텍처가 무엇인지 정의하기에 앞서, 아키텍처란 무엇인가? 

일단 아키텍처(Architecture)란 우리가 만들고자 하는 서비스 혹은 애플리케이션의 구성요소 및 구성요소간의 관계, 외부(Client)와 구성요소간의 관계 등을 정의하고 설명하는 '설계도' 같은 개념이라고 정의할 수 있을 것 같다.

 

 

 

 

그럼 클린 아키텍처란 무엇일까?

"클린 아키텍처(Clean Architecture)"는 소프트웨어 개발에 사용되는 디자인 패턴 중 하나로, 로버트 C. 마틴(Robert C. Martin)이 제안한 아키텍처 원칙이다

 

 

 

클린 아키텍처의 구성 요소는 다음과 같다.

 

• Adapter(Infrastructure)
  • 외부 세계(Web, DB, UI)와 애플리케이션 내부의 도메인 및 로직 사이를 연결하는 역할.
  • 클린 아키텍처의 경계를 형성하며, 시스템의 독립성을 보장
  • in: Controller, Ui
  • out: JpaRepository
• Application(Use Case)
  • 비즈니스 로직의 진입점을 제공
  • 시스템의 usecase를 정의하고 구현하는 서비스가 위치
  • domain과 adapter사이에 상호작용을 조정하고 흐름을 제어
• Domain
  • 시스템의 핵심 비즈니스 로직을 구현
  • 비즈니스 객체, 도메인 서비스 , 도메인 이벤트 등이 포함
  • 외부 요소에 의존하지 않으며 순수성을 보장

 

 

 

 

 

 

 

 

 

 

 

 

3. 클린 아키텍처의 기본 원리

클린 아키텍처는 소프트웨어 시스템을 여러 계층으로 구분하고, 각 계층 간의 의존성을 엄격하게 관리하는 것을 기본 원리로 한다.

 

이는 '의존성 역전 원칙(Dependency Inversion Principle)'과 밀접하게 연관되어 있다.

 

가장 중심에는 애플리케이션의 비즈니스 규칙을 담고 있는 엔티티(Entity)와 유스케이스(Use Cases)가 위치합니다. 이들은 시스템의 핵심 기능을 정의하며, 외부 요소의 변경에 영향을 받지 않는다.

 

 

왜냐하면 클린 아키텍처는 내부 계층이 외부 계층에 의존하지 않도록 설계되어 있기 때문이다. 이를 통해 비즈니스 로직의 독립성을 보장하고, 시스템의 유연성을 높일 수 있다.

 

외부로 갈수록 인터페이스 어댑터, 프레젠테이션, 인프라스트럭처 등의 계층이 위치하며, 이들은 비즈니스 로직과 사용자 인터페이스, 데이터베이스와의 통신을 담당한다.

 

 

이러한 계층 구조는 시스템의 각 부분을 독립적으로 개발하고 테스트할 수 있게 하며, 변경 사항이 한 부분에 국한되도록 한다.

 

 

클린 아키텍처를 적용하기 위해서는 몇 가지 방법을 따라야 한다.

 

1. 시스템의 핵심 비즈니스 로직을 중심으로 엔티티와 유스케이스를 정의

 

2. 각 계층의 책임과 인터페이스를 명확히 하고, 계층 간의 의존성을 역전시키는 방법으로 설계한다. 이는 인터페이스와 추상화를 통해 구현한다.

 

3. 시스템의 외부 요소와의 통신을 담당하는 어댑터와 인프라스트럭처를 구현한다. 이 과정에서 외부 라이브러리나 프레임워크의 의존성은 최소화하고, 시스템의 핵심 로직과 결합도를 낮춘다.

 

4. 테스트를 통해 각 계층의 독립성과 시스템의 전체적인 안정성을 검증한다. 클린 아키텍처는 테스트 용이성을 높이는 구조를 제공한다. 

 

 

 

 

 

 

 

 

 

 

 

 

 

4. 프로젝트 구성 및 회원 기능 개발

들어가기 앞서 완성된 프로젝트 전체 패키지 구조는 다음과 같다.

 

 

 

 

 

 

루트 프로젝트는 빈 프로젝트로 생성해준다.

 

 

 

그리고 나머지 Application, Domain, Infrastructure, WebAPI 는 클래스 라이브러리(C#)으로 생성해준다.

 

 

 

생성 후 모습은 아래와 같다.

 

 

 

Clean Architecture에 따라 각 프로젝트의 dependency를 추가해줘야 한다. 

 

application -> domain

infrastrucrue -> application

WebAPI -> application, Infrastructure

 

으로 설정해준다. Domain은 다른 계층에 의존성을 가져서는 안 된다. 

 

 

참고로 의존성 추가는 종속성 우클릭 후 추가해주면 된다.

 

 

 

 

 

InfraStructure 프로젝트 => NuGet 에서 efcore와 efcore tools, SqlServer 를 설치해준다. 

Entity Framework Core의 핵심 라이브러리로, 데이터베이스와 상호 작용하는 데 중요한 역할을 한다. Java Spring 에서 JPA와 같은 역할이다.

 

추가로 비밀번호 인코딩을 위한 BCrtpy도 설치해주자.

 

 

 

 

그리고 efcore tools는 WebAPI에도 설치해주자.

 

 

 

 

예제로 쓸 엔티티 클래스를 Domain 프로젝트 안에 만들어준다. 

 

- ApplicationUser.cs

namespace Domain.Entities
{
    public class ApplicationUser
    {
        public int Id { get; set; }
        public string? Name { get; set; }
        public string? Email { get; set; }
        public string? Password { get; set; }
    }
}

 

 

 

 

infrastructure 안에 다음 두 클래스를 만들어준다. 

 

- AppDbContext.cs

이 클래스는 Entity Framework Core에서 데이터베이스와의 상호 작용을 관리하는 데이터베이스 컨텍스트(Database Context) 이다. 이 클래스는 데이터베이스 연결을 설정하고, 데이터베이스 테이블과 매핑되는 엔티티(모델)를 정의하는 역할을 한다.

using Domain.Entities;
using Microsoft.EntityFrameworkCore;

namespace infrastructure.Data
{
    internal class AppDbContext : DbContext
    {
        public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
        {
        }

        public DbSet<ApplicationUser> Users { get; set; } // 테이블 명
    }
}

 

 

 

- ServiceContainer.cs

이 클래스는 의존성 주입(Dependency Injection) 설정을 담당하는 서비스 구성 클래스

using infrastructure.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace infrastructure.DependencyInjection
{
    public static class ServiceContainer
    {
        // IServiceCollection에 의존성 주입 구성
        public static IServiceCollection InfrastructureServices(this IServiceCollection services, IConfiguration configuration)
        {
            // AddDbContext 메서드를 사용하여 AppDbContext를 DI 컨테이너에 등록
            services.AddDbContext<AppDbContext>(options =>
                // SQL Server 데이터베이스를 사용하도록 설정
                options.UseSqlServer(
                    configuration.GetConnectionString("Default"),
                    b => b.MigrationsAssembly(typeof(ServiceContainer).Assembly.FullName)
                ),
                ServiceLifetime.Scoped // // DbContext의 생명 주기를 Scoped로 설정 (요청마다 인스턴스를 새로 생성)
            );

            // 의존성 반환
            return services;
        }
    }
}

 

 

 

그리고 appsettings.json에 ConnectionStrings 설정을 해준다.

{
  // 추가
  // 데이터베이스 연결 문자열 설정
  // Server=local : 데이터베이스 서버 주소 지정
  // Database=[] 데이터베이스 이름 지정
  // Trusted_Connection=true : true로 되어 있으면, 사용자 이름과 비밀번호 대신 Windows 사용자 인증 정보를 사용하여 연결
  // Trust Server Certificate=true : SSL 인증서를 사용할 때 서버 인증서를 신뢰할 것인지
  "ConnectionStrings": {
    "Default": "Server=(local); Database=JWTWithCleanArchDB; Trusted_Connection=true; Trust Server Certificate=true;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

 

 

 

솔루션 빌드 후 패키지 관리자 콘솔에 Infrastructure 프로젝트 선택 후 아래 명령어를 입력

add-migration First // First 라는 이름으로 Migration 생성
update-database

 

(마이그레이션(Migration)을 생성한다는 것은 데이터베이스의 스키마(구조) 변경 사항을 코드로 기록하는 것을 의미)

 

 

참고로 패키지 관리자 콘솔은 보기 => 다른 창 => 패키지 관리자 콘솔 에서 활성화 시킬 수 있다. 

 

 

database에 업데이트 하면 아래와 같은 로그들을 볼 수 있다. 

 

 

 

 

 

회원 기능 개발

Application Layer에 Dto와 UseCase를 생성해줬다.

 

 

IUser UseCase를 구현하는 UserRepo는 Infrastructure.Repo 안에 생성해주었다.

 

 

 

의존성 주입을 위해 ServiceContainer에 JWT 관련 설정을 해주었다.

using Application.Contract;
using infrastructure.Data;
using infrastructure.Repo;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace infrastructure.DependencyInjection
{
    public static class ServiceContainer
    {
        // IServiceCollection에 의존성 주입 구성
        public static IServiceCollection InfrastructureServices(this IServiceCollection services, IConfiguration configuration)
        {
            // AddDbContext 메서드를 사용하여 AppDbContext를 DI 컨테이너에 등록
            services.AddDbContext<AppDbContext>(options =>
                // SQL Server 데이터베이스를 사용하도록 설정
                options.UseSqlServer(
                    configuration.GetConnectionString("Default"),
                    b => b.MigrationsAssembly(typeof(ServiceContainer).Assembly.FullName)
                ),
                ServiceLifetime.Scoped // // DbContext의 생명 주기를 Scoped로 설정 (요청마다 인스턴스를 새로 생성)
            );

            // JWT
            services.AddAuthentication(options =>
            {
                options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
            }).AddJwtBearer(options =>
            {
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidateIssuer = true, // 토큰의 발급자(issuer)를 검증
                    ValidateAudience = true, // 토큰의 수신자(audience)를 검증
                    ValidateLifetime = true, // 토큰의 유효 기간을 검증
                    ValidateIssuerSigningKey = true, // 토큰의 서명 키를 검증

                    ValidIssuer = configuration["Jwt:Issuer"], // 발급자의 유효성을 검증할 때 사용할 값
                    ValidAudience = configuration["Jwt:Audience"], // 수신자의 유효성을 검증할 때 사용할 값
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["Jwt:Key"]!)) // 토큰을 검증할 때 사용할 서명 키
                };
            });

            services.AddScoped<IUser, UserRepo>(); // IUser 인터페이스와 UserRepo 클래스 간의 의존성을 DI 컨테이너에 등록
            // 의존성 반환
            return services;
        }
    }
}

 

 

 

 

 

Repo에는 로그인 시 이메일, 아이디 검증 후 token을 생성해 반환하는 로직과, 회원 등록 로직을 작성해주었다.

using Application.Contract;
using Application.DTOs;
using Domain.Entities;
using infrastructure.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.IdentityModel.Tokens;
using System;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

namespace infrastructure.Repo
{
    internal class UserRepo : IUser
    {
        private readonly AppDbContext appDbContext;
        private readonly IConfiguration configuration;

        public UserRepo(AppDbContext appDbContext, IConfiguration configuration)
        {
            this.appDbContext = appDbContext;
            this.configuration = configuration;
        }
        public async Task<LoginResponse> LoginUserAsync(LoginDTO loginDTO)
        {
            var getUser = await FindUserByEmail(loginDTO.Email!); // null이 아님을 보장한다는 의미에서 ! 를 붙임

            if (getUser == null) return new LoginResponse(false, "User not found");

            bool checkPassword = BCrypt.Net.BCrypt.Verify(loginDTO.Password, getUser.Password);
            if (checkPassword)
            {
                return new LoginResponse(true, "Login successfully", GenerateJWTToken(getUser));
            }
            else
            {
                return new LoginResponse(false, "Invalid credentials");
            }
        }

        private string GenerateJWTToken(ApplicationUser getUser)
        {
            var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["Jwt:Key"]!));
            var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
            var userClaims = new[]
            {
                new Claim(ClaimTypes.NameIdentifier, getUser.Id.ToString()),
                new Claim(ClaimTypes.Name, getUser.Name!),
                new Claim(ClaimTypes.Email, getUser.Email!)
            };

            var token = new JwtSecurityToken(
                issuer: configuration["Jwt:Issuer"],
                audience: configuration["Jwt:Audience"],
                claims: userClaims,
                expires: DateTime.Now.AddDays(5),
                signingCredentials: credentials
                );

            return new JwtSecurityTokenHandler().WriteToken(token);
        }

        private async Task<ApplicationUser> FindUserByEmail(string email) =>
            await appDbContext.Users.FirstOrDefaultAsync(u => u.Email == email);

        public async Task<RegistrationResponse> RegisterUserAsync(RegisterUserDTO registerUserDTO)
        {
            var getUser = await FindUserByEmail(registerUserDTO.Email!);
            if (getUser != null)
                return new RegistrationResponse(false, "User Already exist");

            appDbContext.Users.Add(new ApplicationUser()
            {
                Name = registerUserDTO.Name,
                Email = registerUserDTO.Email,
                Password = BCrypt.Net.BCrypt.HashPassword(registerUserDTO.Password)
            });

            await appDbContext.SaveChangesAsync();
            return new RegistrationResponse(true, "Registration completed");
        }
    }
}

 

 

 

마지막으로 컨트롤러를 WebAPI.Controllers 패키지에 만들고, UseCase인 IUser를 주입 받아주자.

using Application.Contract;
using Application.DTOs;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace WebAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class User : ControllerBase
    {
        private readonly IUser user;

        public User(IUser user)
        {
            this.user = user;
        }

        [HttpPost("login")]
        public async Task<ActionResult<LoginResponse>> LogUserIn(LoginDTO loginDTO)
        {
            var result = await user.LoginUserAsync(loginDTO);
            return Ok(result);
        }

        [HttpPost("register")]
        public async Task<ActionResult<LoginResponse>> RegisterUser(RegisterUserDTO registerUserDTO)
        {
            var result = await user.RegisterUserAsync(registerUserDTO);
            return Ok(result);
        }
    }
}

 

 

 

 

 

Swagger에서 회원가입 후 로그인 해보면 토큰이 잘 나온다.

 

 

 

Swagger에서 토큰을 헤더에 담아 요청할 수 있도록 하기 위해 Program.cs에 아래 설정을 추가해준다. 

builder.Services.AddSwaggerGen(swagger =>
{
    swagger.SwaggerDoc("v1", new OpenApiInfo
    {
        Version = "v1",
        Title = "ASP.NET 8 Web API",
        Description = "Authentication with JWT"
    });

    // To Enable authorization using Swagger (JWT)
    swagger.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme()
    {
        Name = "Authorization",
        Type = SecuritySchemeType.ApiKey,
        Scheme = "Bearer",
        BearerFormat = "JWT",
        In = ParameterLocation.Header
    });

    swagger.AddSecurityRequirement(new OpenApiSecurityRequirement
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference
                {
                    Type = ReferenceType.SecurityScheme,
                    Id = "Bearer"
                }
            },
            Array.Empty<string>()
        }
    });
});

 

 

 

 

Authorize 한 후 전체 회원을 반환하는 API를 아래와 같이 만들어주고 테스트해보면 토큰이 없을 때 401 에러를 반환하는 것을 확인할 수 있다.

[HttpGet("list")]
[Authorize]
public async Task<ActionResult<List<UserResponse>>> GetUserList()
{
	return Ok(user.GetUserList());
}

 

- 토큰 없이 요청

 

- 토큰 넣어서 요청

 

 

 

여기서 약간의 삽질을 했는데, Swagger를 써본 사람이라면 아래 사진의 Authorize 버튼에 JWT 토큰을 넣어본 경험이 있을 것이다.

 

 

 

보통 "Bearer " Prefix없이 넣었는데 c#에선 따로 추가해주지 않아서 의존성 주입하던 InfrastructureServices 클래스에 Event를 걸어주었다.

 

헷갈릴까봐 전체 코드를 첨부해뒀다. 

using Application.Contract;
using infrastructure.Data;
using infrastructure.Repo;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace infrastructure.DependencyInjection
{
    public static class ServiceContainer
    {
        // IServiceCollection에 의존성 주입 구성
        public static IServiceCollection InfrastructureServices(this IServiceCollection services, IConfiguration configuration)
        {
            // AddDbContext 메서드를 사용하여 AppDbContext를 DI 컨테이너에 등록
            services.AddDbContext<AppDbContext>(options =>
                // SQL Server 데이터베이스를 사용하도록 설정
                options.UseSqlServer(
                    configuration.GetConnectionString("Default"),
                    b => b.MigrationsAssembly(typeof(ServiceContainer).Assembly.FullName)
                ),
                ServiceLifetime.Scoped // // DbContext의 생명 주기를 Scoped로 설정 (요청마다 인스턴스를 새로 생성)
            );

            // JWT Authentication 추가
            services.AddAuthentication(options =>
            {
                options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
            }).AddJwtBearer(options =>
            {
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidateIssuer = true, // 토큰의 발급자(issuer)를 검증
                    ValidateAudience = true, // 토큰의 수신자(audience)를 검증
                    ValidateLifetime = true, // 토큰의 유효 기간을 검증
                    ValidateIssuerSigningKey = true, // 토큰의 서명 키를 검증

                    ValidIssuer = configuration["Jwt:Issuer"], // 발급자의 유효성을 검증할 때 사용할 값
                    ValidAudience = configuration["Jwt:Audience"], // 수신자의 유효성을 검증할 때 사용할 값
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["Jwt:Key"]!)) // 토큰을 검증할 때 사용할 서명 키
                };

                // Bearer Prefix 없이 요청왔을 때 추가 
                options.Events = new JwtBearerEvents
                {
                    OnMessageReceived = context =>
                    {
                        var token = context.Request.Headers["Authorization"].FirstOrDefault();
                        if (!string.IsNullOrEmpty(token) && !token.StartsWith("Bearer "))
                        {
                            context.Request.Headers["Authorization"] = $"Bearer {token}";
                        }
                        return Task.CompletedTask;
                    }
                };
            });

            services.AddScoped<IUser, UserRepo>(); // IUser 인터페이스와 UserRepo 클래스 간의 의존성을 DI 컨테이너에 등록
            // 의존성 반환
            return services;
        }
    }
}