ASP.NET Core를 사용하여 역할 기반 웹 API를 만드는 방법
여기에 또 다른 훌륭한 방법 블로그 게시물이 있습니다. ASP.NET Core를 사용하여 역할 기반 웹 API 및 Swagger UI를 구축하여 엔드포인트를 시각화하고 상호 작용하는 방법을 보여줍니다.
스베틀로슬라프 노보셀스키
20분 읽기
ASP.NET Core를 사용하여 역할 기반 웹 API를 구축할 때 코드 우선 접근 방식은 강력하고 효율적인 방법이 될 수 있습니다. 이를 사용하여 코드에서 데이터 모델과 관계를 정의한 다음 해당 데이터베이스 스키마를 자동으로 생성할 수 있습니다. 이것이 무엇으로 이어지는가? 개발 주기가 빨라지고 유연성이 향상됩니다. 왜요? 데이터베이스 스키마를 직접 수정하지 않고도 데이터 모델을 빠르고 쉽게 변경할 수 있기 때문입니다. swagger.io에서 Design First 및 Code First 접근 방식에 대해 자세히 알아볼 수 있습니다.
그런 다음 이 자습서에서는 ASP.NET Core 6을 사용하여 역할 기반 웹 API를 만드는 단계를 다룹니다. Swagger UI를 사용하여 엔드포인트 및 MS SQL Server를 데이터베이스로 시각화하고 상호 작용할 것입니다. 애플리케이션에는 인증 모듈과 이벤트 모듈이 포함됩니다. 로그인한 사용자는 자신의 계정과 관련된 이벤트를 볼 수 있으며, 관리자 역할을 가진 사용자는 이벤트를 생성, 업데이트 및 삭제할 수 있습니다.
시작하자!
프로젝트 설정
먼저 프로젝트를 설정해야 합니다. 이를 수행하려면 Visual Studio를 열고 새 프로젝트 만들기로 이동한 다음 ASP.NET Core Web API를 선택합니다.
애플리케이션 이름을 선택하고 다음을 클릭합니다.
API 데이터베이스 설정
애플리케이션을 초기화한 후에는 데이터베이스를 구성해야 합니다. 우리는 EntityFrameworkCore를 ORM으로 사용할 것이므로 데이터베이스를 관리하는 데 도움이 될 것입니다. 이러한 이유로 우리는 몇 가지 패키지를 설치해야 합니다.
패키지를 성공적으로 설치한 후 수행할 다음 작업은 DbContext 를 만드는 것입니다. DataContext.cs 파일을 생성하고 DBContext 클래스를 상속합니다. 여기서는 테이블을 정의하겠습니다.
public class DataContext: DbContext
{
public DataContext(DbContextOptions options): base(options)
{
}
//Define our tables
}
그런 다음 Program.cs 파일을 열고 dbContext를 추가해야 합니다. appsettings.json 파일에서 오는 dbProvider 및 연결 문자열을 지정해야 합니다. dbProvider는 SqlServer, MySql 또는 InMemory 일 수 있습니다.
// Add Db context
var dbProvider = builder.Configuration.GetConnectionString("Provider");
builder.Services.AddDbContext < DataContext > (options =>
{
if (dbProvider == "SqlServer")
{
options.UseSqlServer(builder.Configuration.GetConnectionString("SqlServerConnectionString"));
}
});
다음과 같이 appsettings.json 파일에 ConnectionString 및 Provider를 추가했는지 확인하세요.
…
"ConnectionStrings": {
"Provider": "SqlServer",
"SqlServerConnectionString": "Data Source=(localdb)\\MSSQLLocalDB;Database=HRApplication2;Integrated Security=True;Connect Timeout=30; "
},
…
DbContext를 구성한 후에는 데이터베이스 모델을 생성해야 합니다. 이 경우 둘 사이에 다대다 관계를 설정하려면 두 개의 엔터티(User 및 Event)와 세 번째 테이블(UserEvent)이 필요합니다. 이를 달성하려면 데이터베이스 엔터티를 생성할 수 있는 Models 폴더와 DbModels 하위 폴더를 생성하는 것이 좋습니다.
사용자 모델부터 시작해 보겠습니다. 각 사용자는 고유한 ID, 이메일, 이름, 성, 해시 형식으로 저장될 비밀번호, 데모의 사용자 및 관리자가 될 수 있는 역할, UserEvent 테이블과 관련된 UserEvents를 가지고 있어야 합니다.
public class User
{
public string UserId { get; set; }
public string Email { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string Password { get; set; }
public string Role { get; set; }
public IList <UserEvent> UserEvents { get; set; }
}
이벤트 모델에는 고유한 ID, 제목, 카테고리, 날짜 및 UserEvents 테이블과의 관계도 있어야 합니다.
public class Event
{
public string Id { get; set; }
public string Title { get; set; }
public string Category { get; set; }
public DateTime Date { get; set; }
public IList <UserEvent> UserEvents { get; set; }
}
사용자는 여러 이벤트에 참석할 수 있고 이벤트에는 여러 사용자가 참석할 수 있으므로 이러한 엔터티 간에 다대다 관계를 설정해야 합니다. 이를 위해 UserEvents 라는 추가 테이블을 만듭니다. 이 테이블에는 사용자와 이벤트 엔터티 간의 관계를 설정하는 UserId 및 EventId 열이 포함됩니다.
public class UserEvent
{
public string UserId { get; set; }
public User User { get; set; }
public string EventId { get; set; }
public Event Event { get; set; }
}
데이터베이스 모델을 생성한 후 다음 단계는 이를 DbContext에 등록하는 것입니다. 이를 달성하기 위해 DataContext.cs 파일로 이동하여 모든 엔터티를 DbSets로 추가하고 관계 및 기본 키를 선언할 수 있습니다. 이는 OnModelCreating 메서드를 재정의하고 Fluent API를 활용하여 관계와 키를 구성함으로써 수행할 수 있습니다. 완료되면 결과는 다음과 같이 표시됩니다.
public class DataContext: DbContext
{
public DataContext(DbContextOptions options): base(options)
{
}
public DbSet <User> Users { get; set; }
public DbSet < Event > Events { get; set; }
public DbSet < UserEvent > UserEvents { get; set; }
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
builder.Entity<User>()
.HasKey(u => new {
u.UserId
});
builder.Entity<Event>()
.HasKey(e => new {
e.Id
});
builder.Entity<UserEvent>()
.HasKey(ue => new {
ue.UserId, ue.EventId
});
builder.Entity<UserEvent>()
.HasOne(ue => ue.User)
.WithMany(user => user.UserEvents)
.HasForeignKey(u => u.UserId);
builder.Entity<UserEvent>()
.HasOne(uc => uc.Event)
.WithMany(ev => ev.UserEvents)
.HasForeignKey(ev => ev.EventId);
}
}
데이터베이스 설계가 준비되면 데이터베이스를 생성할 초기 마이그레이션을 생성해야 합니다.
패키지 관리자 콘솔을 열고 다음 명령을 작성합니다.
추가-마이그레이션 초기생성
성공적으로 실행된 후에는 다음을 사용하여 데이터베이스를 업데이트해야 합니다.
데이터베이스 갱신
그런 다음 Microsoft SQL Management Studio를 사용하면 새로 생성된 데이터베이스가 표시됩니다.
AutoMapper 구성
AutoMapper는 한 모델을 다른 모델로 변환하는 데 도움이 됩니다. 입력 모델을 dbModel로 변환합니다. 이렇게 하는 이유는 한 모델의 모든 속성을 다른 모델에 포함할 필요가 없기 때문입니다. 튜토리얼의 뒷부분에서 이를 정확히 어떻게 사용할 것인지 알게 될 것입니다. 그 전에 먼저 구성을 해야 합니다. AutoMapper에 대한 자세한 설명은 공식 문서에서 확인할 수 있습니다.
시작하려면 AutoMaper NuGet 패키지를 설치해야 합니다. 그런 다음 MappingProfiles.cs 파일을 생성하여 모든 매핑을 정의할 수 있습니다. 정리 목적으로 Helpers 폴더 아래에 이 파일을 생성하는 것이 좋습니다.
매핑을 선언하려면 MappingProfiles가 Profile 클래스를 상속해야 하며 CreateMap<from, to>() 메서드를 사용하여 매핑을 선언할 수 있습니다. 모델을 반대 방향으로 매핑하는 기능이 필요한 경우.ReverseMap() 메서드를 포함할 수 있습니다.
매핑이 완료되면 Program.cs 파일로 이동하여 MappingProfiles에 AutoMapper를 등록해야 합니다.
…
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new MappingProfiles());
});
var mapper = config.CreateMapper();
builder.Services.AddSingleton(mapper);
…
인증 설정
인증을 위해 JWT 토큰을 사용할 예정입니다. 이는 당사자 간에 정보를 JSON 개체로 안전하게 전송하는 방법을 제공합니다. 여기에서 JWT 토큰에 대한 자세한 내용을 읽을 수 있습니다. 이를 사용하려면 먼저 필요한 NuGet 패키지를 설치해야 합니다. Microsoft.IdentityModel.Tokens 및 Microsoft.AspNetCore.Authentication.JwtBearer가 모두 필요합니다.
다음으로 appsettings.json 파일에서 일부 토큰 구성을 정의해야 합니다. 이러한 구성에는 발급자, 대상 및 SecretKey가 포함됩니다.
"Jwt": {
"Issuer": "https://localhost:7244/",
"Audience": "https://localhost:7244/",
"Key": "S1u*p7e_r+S2e/c4r6e7t*0K/e7y"
}
토큰 구성이 정의되면 Program.cs 파일에서 JWT 서비스를 구성할 수 있습니다. 여기에는 필요한 유효성 검사 매개변수와 함께 사용될 스키마를 지정하는 작업이 포함됩니다.
…
builder.Services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(o =>
{
o.TokenValidationParameters = new TokenValidationParameters
{
ValidIssuer = builder.Configuration["Jwt:Issuer"],
ValidAudience = builder.Configuration["Jwt:Audience"],
IssuerSigningKey = new SymmetricSecurityKey
(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"])),
ValidateIssuer = true,
ValidateAudience = true,
ValidateLifetime = false,
ValidateIssuerSigningKey = true
};
});
…
app.UseAuthentication()도 추가했는지 확인하세요.
Swagger 설정
Swagger UI를 사용하여 애플리케이션 엔드포인트를 테스트하려면 Program.cs 파일에 app.UseSwaggerUI()를 포함해야 합니다.
그런 다음 JWT 토큰을 사용하여 인증된 엔드포인트를 테스트하는 데 도움이 되는 AuthResponse 필터를 생성해야 합니다. 이를 달성하기 위해 IOperationFilter 인터페이스를 구현하는 AuthResponsesOperationFilter 클래스를 생성할 수 있습니다. Apply 메서드에는 Swagger에 AuthResponse 필터를 추가하는 데 필요한 논리가 포함되어야 합니다.
public class AuthResponsesOperationFilter: IOperationFilter
{
public void Apply(OpenApiOperation operation, OperationFilterContext context)
{
var authAttributes = context.MethodInfo.DeclaringType.GetCustomAttributes(true)
.Union(context.MethodInfo.GetCustomAttributes(true))
.OfType<AuthorizeAttribute>();
if (authAttributes.Any())
{
var securityRequirement = new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
}
},
new List<string>()
}
};
operation.Security = new List<OpenApiSecurityRequirement> {
securityRequirement
};
operation.Responses.Add("401", new OpenApiResponse {
Description = "Unauthorized"
});
}
}
}
그런 다음 Program.cs .AddSwaggerGen 메서드에 필터를 옵션으로 추가했는지 확인하세요.
builder.Services.AddSwaggerGen(option =>
{
option.SwaggerDoc("v1", new OpenApiInfo {
Title = "Northwind CRUD", Version = "v1"
});
option.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
In = ParameterLocation.Header,
Description = "Please enter a valid token",
Name = "Authorization",
Type = SecuritySchemeType.Http,
BearerFormat = "JWT",
Scheme = "bearer"
});
option.OperationFilter < AuthResponsesOperationFilter > ();
}
);
"Swagger란 무엇입니까?"에 대한 자세한 설명을 읽어보실 수 있습니다. 공식 문서에서 .
엔드포인트 등록
구성이 완료되면 레지스터 엔드포인트 생성으로 넘어갈 수 있습니다. 첫 번째 단계는 Models/InputModels 폴더 아래에 있는 RegisterInputModel.cs 파일을 생성하는 것입니다.
등록 프로세스에는 이메일, 이름, 성, 비밀번호 및 확인된 비밀번호 필드가 필요합니다. 이러한 필드는 모두 필수이므로 [필수] 속성을 포함하겠습니다. 이메일 필드에 [EmailAddress] 속성도 포함하겠습니다. 원하는 대로 최소 및 최대 길이와 같은 추가 속성을 추가할 수 있습니다. 그러나 이 데모에서는 이러한 속성을 그대로 사용하겠습니다.
public class RegisterInputModel
{
[EmailAddress]
public string Email { get; set; }
[Required]
public string FirstName { get; set; }
[Required]
public string LastName { get; set; }
[Required]
public string Password { get; set; }
[Required]
public string ConfirmedPassword { get; set; }
}
다음으로 RegisterInputModel과 User 모델 간의 양방향 변환을 가능하게 하는 매핑을 MappingProfiles.cs 파일에 추가해야 합니다.
CreateMap<RegisterInputModel, User>().ReverseMap();
우려 사항을 분리하기 위해 서비스 폴더를 만듭니다. 각 모듈에는 데이터베이스와 상호 작용하기 위한 자체 서비스가 있습니다. AuthService.cs 파일을 생성하고 DataContext 및 Configuration 을 삽입하는 것으로 시작할 수 있습니다.
AuthService.cs의 첫 번째 메소드는 이메일과 역할을 매개변수로 사용하고 사용자 정보가 포함된 JWT 토큰을 반환하는 generateJwtToken 이어야 합니다.
public string GenerateJwtToken(string email, string role)
{
var issuer = this.configuration["Jwt:Issuer"];
var audience = this.configuration["Jwt:Audience"];
var key = Encoding.ASCII.GetBytes(this.configuration["Jwt:Key"]);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new []
{
new Claim("Id", Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Sub, email),
new Claim(JwtRegisteredClaimNames.Email, email),
new Claim(ClaimTypes.Role, role),
new Claim(JwtRegisteredClaimNames.Jti,
Guid.NewGuid().ToString())
}),
Expires = DateTime.UtcNow.AddMinutes(5),
Issuer = issuer,
Audience = audience,
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha512Signature)
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return tokenHandler.WriteToken(token);
}
비밀번호를 해싱하기 위해 BCrypt.Net.BCrypt를 사용합니다. 시작하려면 패키지를 설치하고 파일 시작 부분에 using 문으로 추가해야 합니다.
BC 사용 = BCrypt.Net.BCrypt;
그런 다음 몇 가지 도우미 메서드를 만듭니다. 하나는 주어진 이메일을 가진 사용자가 존재하는지 확인하고, 다른 하나는 사용자를 인증하고, 두 개는 이메일과 ID로 사용자를 얻습니다.
public bool IsAuthenticated(string email, string password)
{
var user = this.GetByEmail(email);
return this.DoesUserExists(email) && BC.Verify(password, user.Password);
}
public bool DoesUserExists(string email)
{
var user = this.dataContext.Users.FirstOrDefault(x => x.Email == email);
return user != null;
}
public User GetById(string id)
{
return this.dataContext.Users.FirstOrDefault(c => c.UserId == id);
}
public User GetByEmail(string email)
{
return this.dataContext.Users.FirstOrDefault(c => c.Email == email);
}
등록 메소드를 생성하기 전에 먼저 고유 ID를 생성하는 메소드를 생성해야 합니다. 이 방법은 다음과 같이 정의할 수 있습니다.
public class IdGenerator
{
public static string CreateLetterId(int length)
{
var random = new Random();
const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
return new string(Enumerable.Repeat(chars, length)
.Select(s => s[random.Next(s.Length)]).ToArray());
}
}
이제 Register 메서드 구현을 진행할 수 있습니다. 이 방법 내에서 고유 ID를 생성하고, 이미 존재하는지 확인하고, 그렇다면 새 ID를 생성합니다. 그런 다음 사용자의 비밀번호를 해시하고 새 사용자를 데이터베이스에 추가합니다.
public User RegisterUser(User model)
{
var id = IdGenerator.CreateLetterId(10);
var existWithId = this.GetById(id);
while (existWithId != null)
{
id = IdGenerator.CreateLetterId(10);
existWithId = this.GetById(id);
}
model.UserId = id;
model.Password = BC.HashPassword(model.Password);
var userEntity = this.dataContext.Users.Add(model);
this.dataContext.SaveChanges();
return userEntity.Entity;
}
AuthController를 아직 생성하지 않았다면 지금이 바로 그때입니다. Controllers 폴더로 이동하여 Controller 클래스를 상속해야 하는 AuthController를 추가합니다. 또한 Swagger에서 인식되도록 [ApiController] 속성과 [Route(“[controller]”)]를 추가해야 합니다.
그런 다음 매퍼, authService 및 로거를 사용하는 경우 이를 삽입하고 RegisterMethod를 생성해야 합니다. 인증되지 않은 사용자만이 접근할 수 있는 게시 요청이어야 합니다. RegisterInputModel을 인수로 받아들이고 ModelState가 유효한지 확인해야 합니다. 그렇다면 해당 사용자에 대한 jwt 토큰을 생성합니다. 전체 메서드는 다음과 같아야 합니다.
[AllowAnonymous]
[HttpPost("Register")]
public ActionResult<string> Register(RegisterInputModel userModel)
{
try
{
if (ModelState.IsValid)
{
if (userModel.Password != userModel.ConfirmedPassword)
{
return BadRequest("Passwords does not match!");
}
if (this.authService.DoesUserExists(userModel.Email))
{
return BadRequest("User already exists!");
}
var mappedModel = this.mapper.Map<RegisterInputModel, User>(userModel);
mappedModel.Role = "User";
var user = this.authService.RegisterUser(mappedModel);
if (user != null)
{
var token = this.authService.GenerateJwtToken(user.Email, mappedModel.Role);
return Ok(token);
}
return BadRequest("Email or password are not correct!");
}
return BadRequest(ModelState);
} catch (Exception error)
{
logger.LogError(error.Message);
return StatusCode(500);
}
}
로그인 기능
로그인 기능은 데이터베이스에서 사용자를 검색해야 한다는 점을 제외하면 유사합니다. 먼저 이번에는 Email 및 Password 필드만 포함하는 LoginInputModel.cs를 만들어야 합니다. MappingProfiles.cs 에도 추가하는 것을 잊지 마세요. 그렇지 않으면 작동하지 않습니다.
public class LoginInputModel
{
[EmailAddress]
[Required]
public string Email { get; set; }
[Required]
public string Password { get; set; }
}
그런 다음 AuthController.cs에서 LoginInputModel을 매개 변수로 사용하고 사용자가 인증되었는지 확인하는 로그인 메서드를 만듭니다. 그렇다면 토큰을 생성해야 합니다. 그렇지 않으면 오류를 반환해야 합니다.
[AllowAnonymous]
[HttpPost("Login")]
public ActionResult <string> Login(LoginInputModel userModel)
{
try
{
if (ModelState.IsValid)
{
if (this.authService.IsAuthenticated(userModel.Email, userModel.Password))
{
var user = this.authService.GetByEmail(userModel.Email);
var token = this.authService.GenerateJwtToken(userModel.Email, user.Role);
return Ok(token);
}
return BadRequest("Email or password are not correct!");
}
return BadRequest(ModelState);
}
catch (Exception error)
{
logger.LogError(error.Message);
return StatusCode(500);
}
}
이벤트용 CRUD 추가
인증이 완료되면 이벤트에 대한 엔드포인트를 개발할 수 있습니다. 우리는 완전한 CRUD 작업을 생성할 것입니다. 사용자와 동일하게 EventService.cs 파일을 생성해야 합니다. 여기에는 ID별로 이벤트를 가져오는 방법, 특정 사용자에 대한 모든 이벤트를 가져오는 방법, 새 이벤트 만들기, 기존 이벤트를 업데이트하는 방법, 이벤트를 삭제하는 방법이 포함됩니다. 전체 파일은 다음과 같아야 합니다.
public class EventService
{
private readonly DataContext dataContext;
public EventService(DataContext dataContext)
{
this.dataContext = dataContext;
}
public Event[] GetAllForUser(string email)
{
var user = this.dataContext.Users
.FirstOrDefault(user => user.Email == email);
return this.dataContext.Events
.Include(ev => ev.UserEvents)
.Where(e => e.UserEvents.FirstOrDefault(ue => ue.UserId == user.UserId) != null)
.ToArray();
}
public Event GetById(string id)
{
return this.dataContext.Events
.Include(ev => ev.UserEvents)
.FirstOrDefault(c => c.Id == id);
}
public Event Create(Event model)
{
var id = IdGenerator.CreateLetterId(6);
var existWithId = this.GetById(id);
while (existWithId != null)
{
id = IdGenerator.CreateLetterId(6);
existWithId = this.GetById(id);
}
model.Id = id;
var eventEntity = this.dataContext.Events.Add(model);
this.dataContext.SaveChanges();
return eventEntity.Entity;
}
public Event Update(Event model)
{
var eventEntity = this.dataContext.Events
.Include(ev => ev.UserEvents)
.FirstOrDefault(c => c.Id == model.Id);
if (eventEntity != null)
{
eventEntity.Title = model.Title != null ? model.Title : eventEntity.Title;
eventEntity.Date = model.Date != null ? model.Date : eventEntity.Date;
eventEntity.Category = model.Category != null ? model.Category : eventEntity.Category;
eventEntity.UserEvents = model.UserEvents.Count! > 0 ? model.UserEvents : eventEntity.UserEvents;
this.dataContext.SaveChanges();
}
return eventEntity;
}
public Event Delete(string id)
{
var eventEntity = this.GetById(id);
if (eventEntity != null)
{
this.dataContext.Events.Remove(eventEntity);
this.dataContext.SaveChanges();
}
return eventEntity;
}
}
다음으로 컨트롤러로 가서 각 요청에 대한 메서드를 설정해야 합니다.
이벤트 모델에서 필요한 모든 데이터를 저장하는 데 사용되는 EventBindingModel을 만듭니다.
GetAll 메서드의 경우 GET 요청을 사용하고 사용자의 토큰을 검색하고 디코딩하며 해당 사용자의 이벤트를 가져오는지 확인하세요.
[HttpGet]
[Authorize]
public ActionResult<EventBindingModel[]> GetAll()
{
try
{
var userEmail = this.authService.DecodeEmailFromToken(this.Request.Headers["Authorization"]);
var events = this.eventService.GetAllForUser(userEmail);
return Ok(this.mapper.Map<Event[], EventBindingModel[]> (events));
} catch (Exception error)
{
logger.LogError(error.Message);
return StatusCode(500);
}
}
…
public string DecodeEmailFromToken(string token)
{
var decodedToken = new JwtSecurityTokenHandler();
var indexOfTokenValue = 7;
var t = decodedToken.ReadJwtToken(token.Substring(indexOfTokenValue));
return t.Payload.FirstOrDefault(x => x.Key == "email").Value.ToString();
}
…
id로 가져오기는 id를 매개변수로 사용하는 GET 요청이어야 합니다.
[HttpGet("{id}")]
[Authorize]
public ActionResult<Event> GetById(string id)
{
try
{
var eventEntity = this.eventService.GetById(id);
if (eventEntity != null)
{
return Ok(eventEntity);
}
return NotFound();
}
catch (Exception error)
{
logger.LogError(error.Message);
return StatusCode(500);
}
}
삭제 엔드포인트는 DELETE 요청이 되며 ID를 인수로 사용합니다.
[HttpDelete("{id}")]
[Authorize(Roles = "Administrator")]
public ActionResult<Event> Delete(string id)
{
try
{
var eventEntity = this.eventService.Delete(id);
if (eventEntity != null)
{
return Ok(eventEntity);
}
return NotFound();
}
catch (Exception error)
{
logger.LogError(error.Message);
return StatusCode(500);
}
}
이벤트 레코드를 추가하거나 업데이트하는 프로세스를 단순화하기 위해 생성 및 업데이트 작업을 위해 특별히 EventInputModel을 생성해 보겠습니다. 이 모델에서는 제목, 카테고리, 날짜, userId 및 eventId를 포함하여 userEvents에 대한 필수 속성만 제공하면 됩니다. 이 모델을 사용하면 각 작업에 대해 Event 모델의 모든 속성을 지정할 필요가 없습니다.
[HttpPost]
public ActionResult<Event> Create(EventInputModel model)
{
try
{
if (ModelState.IsValid)
{
var mappedModel = this.mapper.Map < EventInputModel,
Event > (model);
var eventEntity = this.eventService.Create(mappedModel);
return Ok(eventEntity);
}
return BadRequest(ModelState);
}
catch (Exception error)
{
logger.LogError(error.Message);
return StatusCode(500);
}
}
업데이트는 PUT 요청이며 EventInputModel을 매개변수로 사용합니다.
[HttpPut]
public ActionResult<Event> Update(EventInputModel model)
{
try
{
if (ModelState.IsValid)
{
var mappedModel = this.mapper.Map<EventInputModel, Event>(model);
var eventEntity = this.eventService.Update(mappedModel);
if (eventEntity != null)
{
return Ok(eventEntity);
}
return NotFound();
}
return BadRequest(ModelState);
}
catch (Exception error)
{
logger.LogError(error.Message);
return StatusCode(500);
}
}
역할 기반 인증 추가
특정 작업을 특정 사용자 역할로 제한하기 위해 역할 기반 인증을 사용할 수 있습니다. 예를 들어, 우리 시나리오에서는 이벤트에 대한 생성, 업데이트 및 삭제 끝점에 대한 액세스를 관리자 역할이 있는 사용자로 제한하려고 합니다.
이를 설정하려면 app.UseAuthorization()을 추가해야 합니다. Program.cs 파일에 추가하세요. 그런 다음 제한된 액세스가 필요한 각 엔드포인트에 대해 허용되는 역할을 지정하는 [Authorize] 특성을 추가합니다. 예를 들어 관리자만 삭제 엔드포인트에 액세스할 수 있도록 할 수 있습니다.
… [Authorize(Roles = "Administrator")] public ActionResult<Event> Delete(string id) …
DbSeder 생성
애플리케이션을 실행할 때 테스트 목적이든 다른 이유로든 일부 데이터가 데이터베이스에 미리 채워져 있기를 원하는 경우가 많습니다. 여기서 시드가 필요합니다. 시작하려면 사용하려는 데이터를 정의해야 합니다.
이를 위해 리소스 폴더를 생성하고 두 개의 JSON 파일(사용자용 파일과 이벤트용 파일)을 추가할 수 있습니다. 이러한 파일에는 데이터베이스에 채우려는 데이터가 포함되어 있어야 합니다. 예를 들어 파일은 다음과 같을 수 있습니다.
[
{
"UserId": "USERABCDE",
"FirstName": "Kate",
"LastName": "Lorenz",
"Password": "kate.lorenz",
"Email": "klorenz@hrcorp.com",
"Role": "Administrator"
},
{
"UserId": "ASERABCDE",
"FirstName": "Anthony",
"LastName": "Murray",
"Password": "anthony.murray",
"Email": "amurray@hrcorp.com",
"Role": "User"
}
]
다음으로 Seed 메서드를 포함하는 DbSeeder 클래스를 만들어야 합니다. 이 메서드는 이전에 정의한 데이터를 읽고 이를 데이터베이스에 채웁니다. 이렇게 하려면 dbContext를 매개변수로 전달해야 합니다.
public class DBSeeder
{
public static void Seed(DataContext dbContext)
{
ArgumentNullException.ThrowIfNull(dbContext, nameof(dbContext));
dbContext.Database.EnsureCreated();
var executionStrategy = dbContext.Database.CreateExecutionStrategy();
executionStrategy.Execute(
() => {
using(var transaction = dbContext.Database.BeginTransaction())
{
try
{
// Seed Users
if (!dbContext.Users.Any())
{
var usersData = File.ReadAllText("./Resources/users.json");
var parsedUsers = JsonConvert.DeserializeObject <User[]>(usersData);
foreach(var user in parsedUsers)
{
user.Password = BC.HashPassword(user.Password);
}
dbContext.Users.AddRange(parsedUsers);
dbContext.SaveChanges();
}
// Seed Events
if (!dbContext.Events.Any())
{
var eventsData = File.ReadAllText("./Resources/events.json");
var parsedEvents = JsonConvert.DeserializeObject <Event[]>(eventsData);
dbContext.Events.AddRange(parsedEvents);
dbContext.SaveChanges();
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
}
}
});
}
}
그런 다음 Helpers 폴더에서 Seed 메서드를 실행할 데이터베이스 초기화 확장을 생성해야 합니다.
public static class DBInitializerExtension
{
public static IApplicationBuilder UseSeedDB(this IApplicationBuilder app)
{
ArgumentNullException.ThrowIfNull(app, nameof(app));
using var scope = app.ApplicationServices.CreateScope();
var services = scope.ServiceProvider;
var context = services.GetRequiredService < DataContext > ();
DBSeeder.Seed(context);
return app;
}
}
마지막으로 Program.cs 파일을 열고 app.UseSeedDB() 메서드를 추가해야 합니다. 이렇게 하면 애플리케이션이 시작될 때 데이터베이스에 데이터가 있는지 확인하게 됩니다. 그렇지 않은 경우 이전에 만든 Seed 메서드가 자동으로 정의한 데이터로 채웁니다.
CORS 추가
엔드포인트에 대해 CORS (교차 원본 리소스 공유)를 활성화하려면 Program.cs 파일에 cors 서비스를 추가해야 합니다. 이 경우 모든 지역에서의 액세스를 허용하지만 원하는 경우 특정 도메인을 지정할 수 있습니다.
builder.Services.AddCors(policyBuilder =>
policyBuilder.AddDefaultPolicy(policy =>
policy.WithOrigins("*")
.AllowAnyHeader()
.AllowAnyHeader())
);
그런 다음 app.UseCors();를 추가합니다. 방법.
이를 통해 프런트엔드 애플리케이션에서 API에 액세스할 수 있습니다.
CORS(Cross-Origin Resource Sharing)에 대한 자세한 내용은 여기에서 확인할 수 있습니다.
모든 것을 요약하자면…
ASP .NET Core를 사용하여 역할 기반 API를 만드는 것은 안전하고 확장 가능한 웹 애플리케이션을 구축하는 데 있어서 중요한 측면입니다. 역할 기반 승인을 사용하면 사용자에게 할당된 역할을 기반으로 API 리소스에 대한 액세스를 제어할 수 있습니다. 이를 통해 승인된 사용자만 민감한 데이터에 액세스하거나 중요한 작업을 수행할 수 있으므로 애플리케이션이 더욱 안전하고 안정적으로 만들어집니다. 이 튜토리얼에서는 0부터 1까지 간단한 역할 기반 API를 생성하는 방법을 살펴보았습니다. 데모의 전체 코드는 GitHub 에서 볼 수 있습니다.
여기에서 만든 API를 연결하고 App Builder TM을 사용하여 이를 위한 프런트 엔드 애플리케이션을 빌드하는 방법을 보려면 이 블로그 게시물의 2부(역할 기반 API를 사용하여 App Builder에서 앱 만들기)를 읽어보세요.
