ASP.net Core WebAPI에서 CORS를 활성화하는 방법

내가하려는 일

Azure Free Plan (소스 코드 : https://github.com/killerrin/Portfolio-Backend )에서 호스팅되는 백엔드 ASP.Net Core Web API가 있습니다.

또한 API를 사용하려는 클라이언트 웹 사이트가 있습니다. 클라이언트 응용 프로그램은 Azure에서 호스팅되지 않지만 Github Pages 또는 내가 액세스 할 수있는 다른 웹 호스팅 서비스에서 호스팅됩니다. 이로 인해 도메인 이름이 정렬되지 않습니다.

이것을 살펴보면 웹 API 측에서 CORS를 활성화해야하지만 지금은 몇 시간 동안 거의 모든 것을 시도했지만 작동하지 않습니다.

클라이언트 설정 방법 React.js로 작성된 간단한 클라이언트입니다. Jquery에서 AJAX를 통해 API를 호출하고 있습니다. React 사이트가 작동하므로 그 사실을 알지 못합니다. Jquery API 호출은 시도 1에서 확인한대로 작동합니다. 다음은 호출 방법입니다.

    var apiUrl = "http://andrewgodfroyportfolioapi.azurewebsites.net/api/Authentication";
    //alert(username + "|" + password + "|" + apiUrl);
    $.ajax({
        url: apiUrl,
        type: "POST",
        data: {
            username: username,
            password: password
        },
        contentType: "application/json; charset=utf-8",
        dataType: "json",
        success: function (response) {
            var authenticatedUser = JSON.parse(response);
            //alert("Data Loaded: " + authenticatedUser);
            if (onComplete != null) {
                onComplete(authenticatedUser);
            }
        },
        error: function (xhr, status, error) {
            //alert(xhr.responseText);
            if (onComplete != null) {
                onComplete(xhr.responseText);
            }
        }
    });

내가 시도한 것

시도 1- '적절한'방법

https://docs.microsoft.com/en-us/aspnet/core/security/cors

Microsoft 웹 사이트의이 자습서를 따라 T를 시작했습니다. Startup.cs에서 전역으로 활성화하고 모든 컨트롤러에서 설정하고 모든 작업에서 시도하는 세 가지 옵션을 모두 시도했습니다.

이 방법에 따라 교차 도메인이 작동하지만 단일 컨트롤러 (POST to AccountController)의 단일 작업에서만 작동합니다. 다른 모든 경우에 Microsoft.AspNetCore.Cors미들웨어는 헤더 설정을 거부합니다.

Microsoft.AspNetCore.CorsNUGET을 통해 설치 했으며 버전은1.1.2

다음은 Startup.cs에서 설정하는 방법입니다.

    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        // Add Cors
        services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
        {
            builder.AllowAnyOrigin()
                   .AllowAnyMethod()
                   .AllowAnyHeader();
        }));

        // Add framework services.
        services.AddMvc();
        services.Configure<MvcOptions>(options =>
        {
            options.Filters.Add(new CorsAuthorizationFilterFactory("MyPolicy"));
        });

        ...
        ...
        ...
    }

    // This method gets called by the runtime. Use this method to configure 
    //the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IHostingEnvironment env,
    ILoggerFactory loggerFactory)
    {
        loggerFactory.AddConsole(Configuration.GetSection("Logging"));
        loggerFactory.AddDebug();

        // Enable Cors
        app.UseCors("MyPolicy");

        //app.UseMvcWithDefaultRoute();
        app.UseMvc();

        ...
        ...
        ...
    }

보시다시피, 나는 지시대로 모든 것을하고 있습니다. MVC 앞에 Cors를 두 번 추가하고 작동하지 않을 때 [EnableCors("MyPolicy")]모든 컨트롤러를 배치하려고 시도했습니다.

[Route("api/[controller]")]
[EnableCors("MyPolicy")]
public class AdminController : Controller

시도 2-무차별 강제

https://andrewlock.net/adding-default-security-headers-in-asp-net-core/

이전 시도에서 몇 시간 동안 시도한 후 헤더를 수동으로 설정하여 모든 응답에서 강제로 실행하도록 시도하여 무차별 적으로 시도하려고 생각했습니다. 이 튜토리얼을 따라 모든 응답에 헤더를 수동으로 추가하는 방법에 대해이 작업을 수행했습니다.

이들은 내가 추가 한 헤더입니다

.AddCustomHeader("Access-Control-Allow-Origin", "*")
.AddCustomHeader("Access-Control-Allow-Methods", "*")
.AddCustomHeader("Access-Control-Allow-Headers", "*")
.AddCustomHeader("Access-Control-Max-Age", "86400")

이것들은 내가 시도한 다른 헤더입니다.

.AddCustomHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE")
.AddCustomHeader("Access-Control-Allow-Headers", "content-type, accept, X-PINGOTHER")
.AddCustomHeader("Access-Control-Allow-Headers", "X-PINGOTHER, Host, User-Agent, Accept, Accept: application/json, application/json, Accept-Language, Accept-Encoding, Access-Control-Request-Method, Access-Control-Request-Headers, Origin, Connection, Content-Type, Content-Type: application/json, Authorization, Connection, Origin, Referer")

이 방법을 사용하면 크로스 사이트 헤더가 올바르게 적용되고 개발자 콘솔과 Postman에 표시됩니다. 그러나 문제는 Access-Control-Allow-Origin수표를 통과하는 동안 웹 브라우저가 (내가 믿는) Access-Control-Allow-Headers진술 에 히스토리를 던진다는 것입니다415 (Unsupported Media Type)

따라서 무차별 강제 방법도 작동하지 않습니다

드디어

누구 든지이 일을하고 손을 빌려 줄 수 있습니까, 아니면 올바른 방향으로 나를 가리킬 수 있습니까?

편집하다

따라서 API 호출을 통과하려면 JQuery 사용을 중단하고 순수 자바 스크립트 XMLHttpRequest형식으로 전환해야했습니다 .

시도 1

나는 그럭저럭 Microsoft.AspNetCore.Cors, MindingData의 대답에 따라 대한 작업은이를 제외 Configure퍼팅 방법 app.UseCors전에 app.UseMvc.

또한 options.AllowAnyOrigin()와일드 카드 지원을 위해 Javascript API 솔루션과 혼합 될 때도 작동하기 시작했습니다.

시도 2

그래서 와일드 카드 Access-Control-Allow-Origin가 작동하지 않는다는 유일한 예외를 제외하고는 시도 2 ​​(브 루트 강제)가 작동 하도록했습니다. 따라서 액세스 할 수있는 도메인을 수동으로 설정해야합니다.

이 WebAPI가 모든 사람에게 널리 개방되기를 원하기 때문에 이상적이지는 않지만 분명히 별도의 사이트에서 작동합니다.

app.UseSecurityHeadersMiddleware(new SecurityHeadersBuilder()
    .AddDefaultSecurePolicy()
    .AddCustomHeader("Access-Control-Allow-Origin", "http://localhost:3000")
    .AddCustomHeader("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PUT, PATCH, DELETE")
    .AddCustomHeader("Access-Control-Allow-Headers", "X-PINGOTHER, Content-Type, Authorization"));

매우 간단한 CORS 정책 (XXX 도메인의 모든 요청 허용)이 있으므로 그렇게 복잡하게 만들 필요는 없습니다. 다음을 먼저 시도하십시오 (CORS의 매우 기본적인 구현).

아직 CORS nuget 패키지를 설치하지 않은 경우 설치하십시오.

Install-Package Microsoft.AspNetCore.Cors

startup.cs의 ConfigureServices 메소드에서 CORS 서비스를 추가하십시오.

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(); // Make sure you call this previous to AddMvc
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}

그런 다음 startup.cs의 Configure 메소드에서 다음을 추가하십시오.

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    // Make sure you call this before calling app.UseMvc()
    app.UseCors(
        options => options.WithOrigins("http://example.com").AllowAnyMethod()
    );

    app.UseMvc();
}

이제 가자. 정책은 다른 작업 (예 : 다른 호스트 또는 다른 헤더)에 대해 다른 정책을 원할 때 사용됩니다. 간단한 예제에서는 실제로 필요하지 않습니다. 이 간단한 예제부터 시작하여 필요에 따라 조정하십시오.

추가 자료 : http://dotnetcoretutorials.com/2017/01/03/enabling-cors-asp-net-core/

• 에서 ConfigureServices 추가 services.AddCors(); services.AddMvc () 전에;

• Configure 에서 UseCors 추가

   app.UseCors(builder => builder
       .AllowAnyOrigin()
       .AllowAnyMethod()
       .AllowAnyHeader());   
   app.UseMvc();
  

요점은 app.UseCors전에 추가하는 것 app.UseMvc()입니다.

MVC 파이프 라인이 제어를 요청하고 요청을 종료하기 전에 미들웨어가 시작되도록 MVC 전에 CORS 기능을 선언해야합니다.

위의 방법이 작동하면 API 호출을 수락하고 API를 다른 사람에게 공개하지 않도록 특정 ORIGIN을 구성하도록 변경할 수 있습니다

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options => options.AddPolicy("ApiCorsPolicy", builder =>
    {
        builder.WithOrigins("http://localhost:4200").AllowAnyMethod().AllowAnyHeader();
    }));

    services.AddMvc();
}

configure 메소드에서 방금 작성한 정책을 사용하도록 CORS에 지시하십시오.

app.UseCors("ApiCorsPolicy");
app.UseMvc();

방금이 주제에 대한이 소형 기사를 발견했습니다-https: //dzone.com/articles/cors-in-net-core-net-core-security-part-vi

나를 위해 일한 내 자신의 미들웨어 클래스를 만들었습니다. .net 코어 미들웨어 클래스에 문제가 있다고 생각합니다.

public class CorsMiddleware
{
    private readonly RequestDelegate _next;

    public CorsMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public Task Invoke(HttpContext httpContext)
    {
        httpContext.Response.Headers.Add("Access-Control-Allow-Origin", "*");
        httpContext.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
        httpContext.Response.Headers.Add("Access-Control-Allow-Headers", "Content-Type, X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Date, X-Api-Version, X-File-Name");
        httpContext.Response.Headers.Add("Access-Control-Allow-Methods", "POST,GET,PUT,PATCH,DELETE,OPTIONS");
        return _next(httpContext);
    }
}

// Extension method used to add the middleware to the HTTP request pipeline.
public static class CorsMiddlewareExtensions
{
    public static IApplicationBuilder UseCorsMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<CorsMiddleware>();
    }
}

그리고 startup.cs에서 이런 식으로 사용했습니다.

app.UseCorsMiddleware();

필자의 경우 getMindingData의 답변에 따라 요청 만 잘 작동합니다. 다른 유형의 요청의 경우 다음을 작성해야합니다.

app.UseCors(corsPolicyBuilder =>
   corsPolicyBuilder.WithOrigins("http://localhost:3000")
  .AllowAnyMethod()
  .AllowAnyHeader()
);

추가하는 것을 잊지 마십시오 .AllowAnyHeader()

user8266077 의 답변 을 확장 하기 위해 .NET Core 2.1-preview에서 유스 케이스에 대한 프리 플라이트 요청 에 대한 OPTIONS 응답을 여전히 제공해야한다는 것을 알았습니다 .

// https://stackoverflow.com/a/45844400
public class CorsMiddleware
{
  private readonly RequestDelegate _next;

  public CorsMiddleware(RequestDelegate next)
  {
    _next = next;
  }

  public async Task Invoke(HttpContext context)
  {
    context.Response.Headers.Add("Access-Control-Allow-Origin", "*");
    context.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
    // Added "Accept-Encoding" to this list
    context.Response.Headers.Add("Access-Control-Allow-Headers", "Content-Type, X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Accept-Encoding, Content-Length, Content-MD5, Date, X-Api-Version, X-File-Name");
    context.Response.Headers.Add("Access-Control-Allow-Methods", "POST,GET,PUT,PATCH,DELETE,OPTIONS");
    // New Code Starts here
    if (context.Request.Method == "OPTIONS")
    {
      context.Response.StatusCode = (int)HttpStatusCode.OK;
      await context.Response.WriteAsync(string.Empty);
    }
    // New Code Ends here

    await _next(context);
  }
}

Startup.cs에서 미들웨어를 활성화했습니다.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  app.UseMiddleware(typeof(CorsMiddleware));
  // ... other middleware inclusion such as ErrorHandling, Caching, etc
  app.UseMvc();
}

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {      
       app.UseCors(builder => builder
                .AllowAnyHeader()
                .AllowAnyMethod()
                .SetIsOriginAllowed((host) => true)
                .AllowCredentials()
            );
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors();
    }

나는 DAYS를 위해 이것으로 고투하고 있었다.

app.UseCors(CORS_POLICY);의 TOP 으로 이동 하여 마침내 작동하게되었습니다 Configure().

https://weblog.west-wind.com/posts/2016/sep/26/aspnet-core-and-cors-gotchas

MVC가 요청을 완료하기 전에 헤더를 적용해야하므로> MVC 전에 CORS 기능을 선언해야합니다.

<= 내 앱이 전화하지 않았지만 맨 위로 UseMVC()이동 UseCors()하면 문제가 해결되었습니다.

또한:

• Microsoft.AspNetCore.Cors이전에는 .Net Core 2 이하에서 필요한 NuGet 패키지였습니다. 이제 .Net Core 3 이상의 Microsoft.AspNetCore에 자동으로 포함됩니다.
• builder.AllowAnyOrigin()및 .AllowCredentials()CORS 옵션은 이제 닷넷 코어 3 이상에서 상호 배타적
• CORS 정책에 따라 Angular에서 서버를 호출해야합니다 https. .Net Core 서버의 CORS 구성에 관계없이 http URL에서 CORS 오류가 발생하는 것 같습니다. 예를 들어 http://localhost:52774/api/ContactsCORS 오류가 발생합니다. https://localhost:44333/api/Contacts작동 하도록 URL을 변경하기 만하면 됩니다.

추가 사항 :

필자의 경우 CORS는 app.UseCors()위로 이동할 때까지 작동하지 않습니다 app.UseEndpoints(endpoints => endpoints.MapControllers()).

위의 절차 중 어느 것도 도움이되지 않았 으며 문제를 해결 한 기사 를 읽었습니다 .

아래는 코드입니다.

public void ConfigureServices(IServiceCollection services)
{
    // Add service and create Policy with options
    services.AddCors(options =>
    {
        options.AddPolicy("CorsPolicy",
            builder => builder.AllowAnyOrigin()
            .AllowAnyMethod()
            .AllowAnyHeader()
            .AllowCredentials() );
    });


    services.AddMvc(); 
}

과

public void Configure(IApplicationBuilder app)
{
    // ...

    // global policy - assign here or on each controller
    app.UseCors("CorsPolicy");

내 행동 방법의 상단에

[EnableCors("CorsPolicy")]

jQuery.support.cors = true;Ajax 호출 전에 추가해보십시오

API로 보내는 데이터가 불안정 할 수도 있습니다.

다음 JSON 함수를 추가하십시오.

        var JSON = JSON || {};

    // implement JSON.stringify serialization
    JSON.stringify = JSON.stringify || function (obj) {

        var t = typeof (obj);
        if (t != "object" || obj === null) {

            // simple data type
            if (t == "string") obj = '"' + obj + '"';
            return String(obj);

        }
        else {

            // recurse array or object
            var n, v, json = [], arr = (obj && obj.constructor == Array);

            for (n in obj) {
                v = obj[n]; t = typeof (v);

                if (t == "string") v = '"' + v + '"';
                else if (t == "object" && v !== null) v = JSON.stringify(v);

                json.push((arr ? "" : '"' + n + '":') + String(v));
            }

            return (arr ? "[" : "{") + String(json) + (arr ? "]" : "}");
        }
    };

    // implement JSON.parse de-serialization
    JSON.parse = JSON.parse || function (str) {
        if (str === "") str = '""';
        eval("var p=" + str + ";");
        return p;
    };

그런 다음 데이터에서 객체를 다음으로 변경하십시오.

    data: JSON.stringify({
        username: username,
        password: password
    }),

가장 간단한 해결책은 추가입니다

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseHsts();
        }

        app.UseCors(options => options.AllowAnyOrigin());

        app.UseHttpsRedirection();
        app.UseMvc();
    }

Startup.cs에.

CORS 미들웨어 를 사용하는 경우 오리진 헤더 를 확인하여 실제로 CORS 요청 인지 확인해야 한다고 생각합니다 .

 public class CorsMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMemoryCache _cache;
    private readonly ILogger<CorsMiddleware> _logger;

    public CorsMiddleware(RequestDelegate next, IMemoryCache cache, ILogger<CorsMiddleware> logger)
    {
        _next = next;
        _cache = cache;
        _logger = logger;
    }
    public async Task InvokeAsync(HttpContext context, IAdministrationApi adminApi)
    {
        if (context.Request.Headers.ContainsKey(CorsConstants.Origin) || context.Request.Headers.ContainsKey("origin"))
        {
            if (!context.Request.Headers.TryGetValue(CorsConstants.Origin, out var origin))
            {
                context.Request.Headers.TryGetValue("origin", out origin);
            }

            bool isAllowed;
            // Getting origin from DB to check with one from request and save it in cache 
            var result = _cache.GetOrCreateAsync(origin, async cacheEntry => await adminApi.DoesExistAsync(origin));
            isAllowed = result.Result.Result;

            if (isAllowed)
            {
                context.Response.Headers.Add(CorsConstants.AccessControlAllowOrigin, origin);
                context.Response.Headers.Add(
                    CorsConstants.AccessControlAllowHeaders,
                    $"{HeaderNames.Authorization}, {HeaderNames.ContentType}, {HeaderNames.AcceptLanguage}, {HeaderNames.Accept}");
                context.Response.Headers.Add(CorsConstants.AccessControlAllowMethods, "POST, GET, PUT, PATCH, DELETE, OPTIONS");

                if (context.Request.Method == "OPTIONS")
                {
                    _logger.LogInformation("CORS with origin {Origin} was handled successfully", origin);
                    context.Response.StatusCode = (int)HttpStatusCode.NoContent;
                    return;
                }

                await _next(context);
            }
            else
            {
                if (context.Request.Method == "OPTIONS")
                {
                    _logger.LogInformation("Preflight CORS request with origin {Origin} was declined", origin);
                    context.Response.StatusCode = (int)HttpStatusCode.NoContent;
                    return;
                }

                _logger.LogInformation("Simple CORS request with origin {Origin} was declined", origin);
                context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
                return;
            }
        }

        await _next(context);
    }

MindingData의 답변에 대한 귀하의 의견을 바탕으로 CORS와 아무런 관련이 없으며 정상적으로 작동합니다.

컨트롤러 작업이 잘못된 데이터를 반환하고 있습니다. HttpCode 415는 "지원되지 않는 미디어 유형"을 의미합니다. 이것은 잘못된 형식을 컨트롤러에 전달하거나 (예 : XML을 json 만 허용하는 컨트롤러에 전달) 잘못된 유형을 반환 할 때 (xml 만 반환하도록 선언 된 컨트롤러에서 Xml을 반환) 발생합니다.

나중에 [Produces("...")]행동 에 속성이 있는지 확인하십시오.

나를 위해, 그것은 내가 사용하고있는 코드와 관련이 없었습니다. Azure의 경우 사이드 메뉴에서 "CORS"항목 인 앱 서비스 설정으로 이동해야했습니다. 거기에 내가 요청한 도메인을 추가해야했습니다. 내가 그것을 가지고 일단, 모든 것이 마법이었다.

launchSettings.json의 iisSettings에서 anonymousAuthentication을 true로 설정하십시오.

"iisSettings": {
    "windowsAuthentication": true,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:4200/",
      "sslPort": 0
    }
  }

그런 다음 Startup.cs의 ConfigureServices에서 services.AddMvc 전에 다음을 추가하십시오.

services.AddCors(options => options.AddPolicy("ApiCorsPolicy", builder =>
{
    builder
        .AllowAnyOrigin()
        .WithHeaders(HeaderNames.AccessControlAllowHeaders, "Content-Type")
        .AllowAnyMethod()
        .AllowCredentials();
}));

그런 다음 configure 메소드에서 app.UseMvc () 전에 다음을 추가하십시오.

app.UseCors("ApiCorsPolicy");

.Net CORE 3.1을 사용하고 있으며 코드가 실제로 작동하기 시작했지만 디버깅 환경이 손상되었다는 것을 깨달았을 때 벽에 머리를 두드리는 데 오랜 시간을 보냈습니다. 따라서 문제를 해결하려는 경우 2 가지 힌트가 있습니다. 문제:

1. ASP.NET 미들웨어를 사용하여 응답 헤더를 기록하려고하면 "Access-Control-Allow-Origin"헤더가 있어도 표시되지 않습니다. 어떻게 해야할지 모르겠지만 파이프 라인 외부에 추가 된 것 같습니다 (결국 그것을 보려면 wireshark를 사용해야했습니다).

2. .NET CORE는 요청에 "Origin"헤더가 없으면 응답에 "Access-Control-Allow-Origin"을 보내지 않습니다. Postman은 이것을 자동으로 설정하지 않으므로 직접 추가해야합니다.

제 경우에는 UserRouting 전에 UseCors로 수정되었습니다.

.NET 코어 3.1

나를 위해 일했고 문서가 어떻게하는지 :

스타트 업 수업에서 :

readonly string MyAllowSpecificOrigins = "_myAllowSpecificOrigins"; 

ConfigureServices () 메소드에서 :

    services.AddCors(options =>
    {
        options.AddPolicy(MyAllowSpecificOrigins,
        builder =>
        {
            builder.WithOrigins("http://example.com",
                                "http://www.contoso.com");
        });
    });

Configure () 메소드에서 :

    app.UseCors(MyAllowSpecificOrigins);  

https://docs.microsoft.com/en-us/aspnet/core/security/cors?view=aspnetcore-3.1

위의 MindingData의 답변을 얻었지만 Microsoft.AspNetCore.Cors 대신 Microsoft.AspNet.Cors를 사용해야했습니다. Visual Studio 2019에서 .NetCore 웹 응용 프로그램 API 프로젝트를 사용하고 있습니다.

그만큼

Microsoft.AspNetCore.Cors

내장 기능으로 CORS를 수행 할 수 있지만 OPTIONS 요청은 처리하지 않습니다. 지금까지 가장 좋은 해결 방법은 이전 게시물에서 제안한대로 새 미들웨어를 작성하는 것입니다. 다음 게시물에서 정답으로 표시된 답변을 확인하십시오.

.NET Core Web API에서 CORS에 대한 OPTIONS 헤더 사용

간단하고 쉬운 방법입니다.

1. 패키지 설치

Install-Package Microsoft.AspNetCore.Cors

2. startup.cs 파일에 아래 코드를 넣으십시오.

app.UseCors(options => options.AllowAnyOrigin());

내 코드는 다음과 같습니다.)

  app.Use((ctx, next) =>
        {
            ctx.Response.Headers.Add("Access-Control-Allow-Origin", ctx.Request.Headers["Origin"]);
            ctx.Response.Headers.Add("Access-Control-Allow-Methods", "*");
            ctx.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
            ctx.Response.Headers.Add("Access-Control-Allow-Headers", "AccessToken,Content-Type");
            ctx.Response.Headers.Add("Access-Control-Expose-Headers", "*");
            if (ctx.Request.Method.ToLower() == "options")
            {
                ctx.Response.StatusCode = 204;

                return Task.CompletedTask;
            }
            return next();
        });

여기 내가 어떻게했는지.

나는 일부 답변 에서 컨트롤러를 설정 app.UserCors("xxxPloicy")하고 넣는 것을 알 수 있습니다 [EnableCors("xxxPloicy")]. 둘 다 할 필요는 없습니다.

단계는 다음과 같습니다.

ConfigureServices 내의 Startup.cs에 다음 코드를 추가하십시오.

    services.AddCors(c=>c.AddPolicy("xxxPolicy",builder => {
        builder.AllowAnyOrigin()
        .AllowAnyMethod()
        .AllowAnyHeader();
    }));

프로젝트 전체에 적용하려면 Startup.cs의 메소드 구성에 다음 코드를 추가하십시오.

app.UseCors("xxxPolicy");

또는

특정 컨트롤러에 추가하려면 아래 표시된대로 enable cors 코드를 추가하십시오.

[EnableCors("xxxPolicy")]
[Route("api/[controller]")]
[ApiController]
public class TutorialController : ControllerBase {}

자세한 내용 은 다음을 참조하십시오

사용자 정의 조치 / 컨트롤러 속성을 사용하여 CORS 헤더를 설정하십시오.

예:

public class AllowMyRequestsAttribute : ControllerAttribute, IActionFilter
{
    public void OnActionExecuted(ActionExecutedContext context)
    {
        // check origin
        var origin = context.HttpContext.Request.Headers["origin"].FirstOrDefault();
        if (origin == someValidOrigin)
        {
            context.HttpContext.Response.Headers.Add("Access-Control-Allow-Origin", origin);
            context.HttpContext.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
            context.HttpContext.Response.Headers.Add("Access-Control-Allow-Headers", "*");
            context.HttpContext.Response.Headers.Add("Access-Control-Allow-Methods", "*");
            // Add whatever CORS Headers you need.
        }
    }

    public void OnActionExecuting(ActionExecutingContext context)
    {
        // empty
    }
}

그런 다음 웹 API 컨트롤러 / 액션에서 :

[ApiController]
[AllowMyRequests]
public class MyController : ApiController
{
    [HttpGet]
    public ActionResult<string> Get()
    {
        return "Hello World";
    }
}

을 사용 app.UseHttpsRedirection()하고 있고 SSL 포트가 아닌 경우 여기에 대답하기 위해 추가하십시오 .

클라이언트로 asz.web 웹 API 코어와 백엔드로 blazor webassembly를 사용했으며 cors 문제도있었습니다.

이 코드로 솔루션을 찾았습니다.

내 ASP.Net 핵심 웹 API Startup.cs ConfigureServices 및 Configure 메서드 첫 줄은 다음과 같습니다.

public void ConfigureServices(IServiceCollection services)
{
   services.AddCors(options => options.AddPolicy("ApiCorsPolicy", builder =>
   {
        builder.WithOrigins("http://example.com").AllowAnyMethod().AllowAnyHeader();
    }));

 //other code below...
}

내 구성 방법 :

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseCors(
        options =>   options.WithOrigins("http://example.com").AllowAnyMethod().AllowAnyHeader()
            );
 //other code below...
}

변경 http://example.com클라이언트 도메인 또는 IP 주소와

services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
                .AddJsonOptions(options => {
                    var resolver = options.SerializerSettings.ContractResolver;
                    if (resolver != null)
                        (resolver as DefaultContractResolver).NamingStrategy = null;
                });

            services.AddDbContext<PaymentDetailContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DevConnection"))); //Dependency Injection
            // options => options.UseSqlServer() Lamda Expression

            services.AddCors(options =>
            {
                options.AddPolicy(MyAllowSpecificOrigins,
                    builder =>
                    {
                        builder.WithOrigins("http://localhost:4200").AllowAnyHeader()
                                .AllowAnyMethod(); ;
                    });
            });