Migrate Authentication/Authorization Functionality from ASP.NET 4.8 to ASP.NET Core 6

I am migrating an application from ASP.NET 4.8 to ASP.NET Core 6.

It is hosted in Azure, it uses Azure App Service, App Registration, App Roles, Enterprise Application.

The following is used in the ASP.NET 4.8 project:

App_Start/Startup.Auth.cs:

public partial class Startup
{
    public void ConfigureAuth(IAppBuilder app)
    {
        var clientId = ConfigurationManager.AppSettings["ida:ClientId"];
        var aADInstance = ConfigurationManager.AppSettings["ida:AADInstance"];
        var tenantId = ConfigurationManager.AppSettings["ida:TenantId"];
        var postLogoutRedirectUri = ConfigurationManager.AppSettings["ida:PostLogoutRedirectUri"];
        var authority = string.Format(CultureInfo.InvariantCulture, aADInstance, tenantId);

        app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);

        app.UseCookieAuthentication(new CookieAuthenticationOptions
        {
            AuthenticationType = "Cookies",
            CookieManager = new SystemWebChunkingCookieManager()
        });

        app.UseOpenIdConnectAuthentication(
            new OpenIdConnectAuthenticationOptions
            {
                ClientId = clientId,
                Authority = authority,
                PostLogoutRedirectUri = postLogoutRedirectUri,
                TokenValidationParameters = new TokenValidationParameters
                {
                    NameClaimType = ClaimTypes.Name,
                    RoleClaimType = ClaimTypes.Role
                },
                Notifications = new OpenIdConnectAuthenticationNotifications
                {
                    AuthenticationFailed = context =>
                    {
                        context.HandleResponse();
                        context.OwinContext.Response.Redirect("/");
                        return Task.FromResult(0);
                    }
                }
            }
        );
    }
}

Startup.cs:

using Microsoft.Owin;
using Owin;

[assembly: OwinStartup(typeof(App.Startup))]
namespace App
{
    public partial class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);
        }
    }
}

CustomAuthorizeAttribute.cs:

public class CustomAuthorizeAttribute : AuthorizeAttribute
{
    private readonly string[] _roles;

    public CustomAuthorizeAttribute(params string[] roles)
    {
        _roles = roles;
    }

    protected override bool AuthorizeCore(HttpContextBase httpContext)
    {
        return Authorize(httpContext);
    }

    protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext)
    {
        base.HandleUnauthorizedRequest(filterContext);
    }

    public bool GetAuthorization(HttpContextBase httpContext)
    {
        return Authorize(httpContext);
    }

    protected bool Authorize(HttpContextBase httpContext)
    {
        var authorize = false;

        var coreDb = new CoreDbContext();

        foreach (var role in _roles)
        {
            var adGroups = coreDb.GetAdGroupsFromRole(role);

            foreach (var adGroup in adGroups.ResultSet1)
            {
                if (httpContext.User.IsInRole(adGroup.ActiveDirectoryGroup))
                {
                    authorize = true;
                    break;
                }
            }

            if (authorize)
                break;
        }

        return authorize;
    }
}

AccountController.cs:

public class AccountController : Controller
{
    public void SignIn()
    {
        if (!Request.IsAuthenticated)
        {
            HttpContext.GetOwinContext().Authentication.Challenge(
                new AuthenticationProperties
                {
                    RedirectUri = "/"
                },
                OpenIdConnectAuthenticationDefaults.AuthenticationType
            );
        }
    }

    public void SignOut()
    {
        HttpContext.GetOwinContext().Authentication.SignOut(
            OpenIdConnectAuthenticationDefaults.AuthenticationType,
            CookieAuthenticationDefaults.AuthenticationType
        );
    }
}

CustomAuthorizeAttribute in use:

[CustomAuthorize("SomeAzureAppRole")]

_Login.cshtml:

@if (Request.IsAuthenticated)
{
    <text>
        Hello, @User.Identity.Name <a href="/Account/SignOut"> Sign Out</a>
    </text>
}

Web.config/appSettings:

<appSettings>
    <add key="ida:ClientId" value="SomeGuidValue" />
    <add key="ida:AADInstance" value="https://login.microsoftonline.com/{0}" />
    <add key="ida:TenantId" value="SomeGuidValue" />
    <add key="ida:PostLogoutRedirectUri" value="https://localhost:SomePortNumber/" />
</appSettings>

Examples that provide similar functionality in ASP.NET Core 6?