자습서: 외부 테넌트에서 인증을 위한 Angular SPA 준비

아티클
06/19/2024

이 자습서는 Angular 단일 페이지 애플리케이션(SPA(권한 있는 액세스 보호))을 빌드하고 Microsoft Entra 관리 센터를 사용하여 인증을 준비하는 방법을 보여 주는 시리즈의 2부입니다. 이 시리즈의 1부에서는 애플리케이션을 등록하고 외부 테넌트에 사용자 흐름을 구성했습니다. 이 자습서에서는 npm을 사용하여 Angular SPA를 만들고 인증 및 권한 부여에 필요한 파일을 만드는 방법을 보여 줍니다.

이 자습서에서는 다음을 수행합니다.

Visual Studio Code에서 Angular 프로젝트 만들기
애플리케이션에 대한 사용자 인터페이스 구성
홈 및 보호된 구성 요소 구성

필수 조건

자습서: Angular SPA에서 사용자를 인증하기 위해 외부 테넌트 준비.
React 애플리케이션을 지원하는 모든 IDE(통합 개발 환경)를 사용할 수 있지만 이 자습서에서는 Visual Studio Code를 사용합니다.
Node.js

Angular 프로젝트 만들기

이 섹션에서는 Visual Studio Code에서 Angular CLI를 사용하여 새 Angular 프로젝트를 만듭니다.

Visual Studio Code를 열어 파일>폴더 열기...를 선택합니다. 프로젝트를 만들려는 위치로 이동하여 선택합니다.
터미널 >새 터미널을 선택하여 새 터미널을 엽니다.

다음 명령을 실행하여 이름이 angularspalocal인 새 Angular 프로젝트를 만들고 Angular Material 구성 요소 라이브러리, MSAL 브라우저, MSAL Angular를 설치하고 홈 및 보호된 구성 요소를 만듭니다.

npm install -g @angular/cli@14.2.0
ng new angularspalocal --routing=true --style=css --strict=false
cd angularspalocal
npm install @angular/material@13.0.0 @angular/cdk@13.0.0
npm install @azure/msal-browser@2.37.0 @azure/msal-angular@2.5.7
ng generate component home
ng generate component guarded

UI 요소 구성

다음 단계에서는 애플리케이션의 UI 요소를 구성합니다. 색과 글꼴을 정의하기 위해 CSS 스타일이 애플리케이션에 추가되었습니다. 애플리케이션 머리글과 바닥글은 HTML 파일에 정의되고 CSS 스타일은 애플리케이션의 홈페이지에 추가됩니다.

src/styles.css를 열고 기존 코드를 다음 코드 조각으로 바꿉니다.

@import '~@angular/material/prebuilt-themes/deeppurple-amber.css';
html, body { height: 100%; }
body { margin: 0; font-family: Roboto, "Helvetica Neue", sans-serif; }

src/app/app.component.html을 열고 기존 코드를 다음 코드 조각으로 바꿉니다.

  <mat-toolbar color="primary">
      <a class="title" href="/">{{ title }}</a>
      <div class="toolbar-spacer"></div>
      <a mat-button [routerLink]="['guarded']">Guarded Component</a>
      <button mat-raised-button *ngIf="!loginDisplay" (click)="login()">Login</button>
      <button mat-raised-button color="accent" *ngIf="loginDisplay" (click)="logout()">Logout</button>
    </mat-toolbar>
    <div class="container">
      <!--This is to avoid reload during acquireTokenSilent() because of hidden iframe -->
      <router-outlet *ngIf="!isIframe"></router-outlet>
    </div>
    <footer *ngIf="loginDisplay">
      <mat-toolbar>
        <div class="footer-text"> How did we do? <a
            href="https://forms.office.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR_ivMYEeUKlEq8CxnMPgdNZUNDlUTTk2NVNYQkZSSjdaTk5KT1o4V1VVNS4u"
            target="_blank"> Share your experience with us!</a>
        </div>
      </mat-toolbar>
    </footer>

src/app/app.component.css를 열고 기존 코드를 다음 코드 조각으로 바꿉니다.

.toolbar-spacer {
  flex: 1 1 auto;
}

a.title {
  color: white;
}

footer {
  position: fixed;
  left: 0;
  bottom: 0;
  width: 100%;
  color: white;
  text-align: center;
}

.footer-text {
  font-size: small;
  text-align: center;
  flex: 1 1 auto;
}

애플리케이션 구성 요소 구성

이 섹션에서는 애플리케이션의 홈 및 보호된 구성 요소를 구성합니다. 홈 구성 요소는 애플리케이션의 방문 페이지이며 보호된 구성 요소는 인증된 사용자만 액세스할 수 있는 페이지입니다.

src/app/home/home.component.ts를 열고 기존 코드를 다음 코드 조각으로 바꿉니다.

import { Component, Inject, OnInit } from '@angular/core';
import { Subject } from 'rxjs';
import { filter } from 'rxjs/operators';

import { MsalBroadcastService, MsalGuardConfiguration, MsalService, MSAL_GUARD_CONFIG } from '@azure/msal-angular';
import { AuthenticationResult, InteractionStatus, InteractionType } from '@azure/msal-browser';

import { createClaimsTable } from '../claim-utils';

@Component({
  selector: 'app-home',
  templateUrl: './home.component.html',
  styleUrls: ['./home.component.css'],
})
export class HomeComponent implements OnInit {
  loginDisplay = false;
  dataSource: any = [];
  displayedColumns: string[] = ['claim', 'value', 'description'];

  private readonly _destroying$ = new Subject<void>();

  constructor(
    @Inject(MSAL_GUARD_CONFIG)
    private msalGuardConfig: MsalGuardConfiguration,
    private authService: MsalService,
    private msalBroadcastService: MsalBroadcastService
  ) { }

  ngOnInit(): void {

    this.msalBroadcastService.inProgress$
      .pipe(
        filter((status: InteractionStatus) => status === InteractionStatus.None)
      )
      .subscribe(() => {
        this.setLoginDisplay();
        this.getClaims(
          this.authService.instance.getActiveAccount()?.idTokenClaims
        );
      });
  }

  setLoginDisplay() {
    this.loginDisplay = this.authService.instance.getAllAccounts().length > 0;
  }

  getClaims(claims: any) {
    if (claims) {
      const claimsTable = createClaimsTable(claims);
      this.dataSource = [...claimsTable];
    }
  }

  signUp() {
    if (this.msalGuardConfig.interactionType === InteractionType.Popup) {
      this.authService.loginPopup({
        scopes: [],
        prompt: 'create',
      })
        .subscribe((response: AuthenticationResult) => {
          this.authService.instance.setActiveAccount(response.account);
        });
    } else {
      this.authService.loginRedirect({
        scopes: [],
        prompt: 'create',
      });
    }

  }

  // unsubscribe to events when component is destroyed
  ngOnDestroy(): void {
    this._destroying$.next(undefined);
    this._destroying$.complete();
  }
}

src/app/home/home.component.html을 열고 기존 코드를 다음 코드 조각으로 바꿉니다. 이 코드는 애플리케이션 홈페이지의 HTML 요소를 정의합니다.

<mat-card class="card-section" *ngIf="!loginDisplay">
  <mat-card-title>Angular single-page application built with MSAL Angular</mat-card-title>
  <mat-card-subtitle>Sign in with Microsoft Entra External ID</mat-card-subtitle>
  <mat-card-content>This sample demonstrates how to configure MSAL Angular to sign up, sign in and sign out with Microsoft Entra External ID</mat-card-content>
  <button mat-raised-button color="primary" (click)="signUp()">Sign up</button>
</mat-card>
<br>
<p class="text-center" *ngIf="loginDisplay"> See below the claims in your <strong> ID token </strong>. For more
  information, visit: <span>
    <a href="https://docs.microsoft.com/en-us/azure/active-directory/develop/id-tokens#claims-in-an-id-token">
      docs.microsoft.com </a>
  </span>
</p>
<div id="table-container">
  <table mat-table [dataSource]="dataSource" class="mat-elevation-z8" *ngIf="loginDisplay">
    <!-- Claim Column -->
    <ng-container matColumnDef="claim">
      <th mat-header-cell *matHeaderCellDef> Claim </th>
      <td mat-cell *matCellDef="let element"> {{element.claim}} </td>
    </ng-container>
    <!-- Value Column -->
    <ng-container matColumnDef="value">
      <th mat-header-cell *matHeaderCellDef> Value </th>
      <td mat-cell *matCellDef="let element"> {{element.value}} </td>
    </ng-container>
    <!-- Value Column -->
    <ng-container matColumnDef="description">
      <th mat-header-cell *matHeaderCellDef> Description </th>
      <td mat-cell *matCellDef="let element"> {{element.description}} </td>
    </ng-container>
    <tr mat-header-row *matHeaderRowDef="displayedColumns sticky: true"></tr>
    <tr mat-row *matRowDef="let row; columns: displayedColumns;"></tr>
  </table>
</div>

src/app/home/home.component.css를 엽니다. 기존 코드를 다음 코드 조각으로 바꿉니다.

#table-container {
  height: '100vh';
  overflow: auto;
}

table {
  margin: 3% auto 1% auto;
  width: 70%;
}

.mat-row {
  height: auto;
}

.mat-cell {
  padding: 8px 8px 8px 0;
}

p {
  text-align: center;
}

.card-section {
  margin: 10%;
  padding: 5%;
}

src/app/guarded/guarded.component.ts를 열고 기존 코드를 다음 코드 조각으로 바꿉니다.

import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-guarded',
  templateUrl: './guarded.component.html',
  styleUrls: ['./guarded.component.css']
})
export class GuardedComponent implements OnInit {

  constructor() { }

  ngOnInit(): void {
  }

}

src/app/ 폴더에 claim-utils.ts라는 파일을 만들고 다음 코드 조각을 붙여넣습니다.

/**
 * Populate claims table with appropriate description
 * @param {Record} claims ID token claims
 * @returns claimsTable
 */
export const createClaimsTable = (claims: Record<string, string>): any[] => {
  const claimsTable: any[] = [];

  Object.keys(claims).map((key) => {
    switch (key) {
      case 'aud':
        populateClaim(
          key,
          claims[key],
          "Identifies the intended recipient of the token. In ID tokens, the audience is your app's Application ID, assigned to your app in the Azure portal.",
          claimsTable
        );
        break;
      case 'iss':
        populateClaim(
          key,
          claims[key],
          'Identifies the issuer, or authorization server that constructs and returns the token. It also identifies the Azure AD tenant for which the user was authenticated. If the token was issued by the v2.0 endpoint, the URI will end in /v2.0.',
          claimsTable
        );
        break;
      case 'iat':
        populateClaim(
          key,
          changeDateFormat(+claims[key]),
          '"Issued At" indicates the timestamp (UNIX timestamp) when the authentication for this user occurred.',
          claimsTable
        );
        break;
      case 'nbf':
        populateClaim(
          key,
          changeDateFormat(+claims[key]),
          'The nbf (not before) claim dictates the time (as UNIX timestamp) before which the JWT must not be accepted for processing.',
          claimsTable
        );
        break;
      case 'exp':
        populateClaim(
          key,
          changeDateFormat(+claims[key]),
          "The exp (expiration time) claim dictates the expiration time (as UNIX timestamp) on or after which the JWT must not be accepted for processing. It's important to note that in certain circumstances, a resource may reject the token before this time. For example, if a change in authentication is required or a token revocation has been detected.",
          claimsTable
        );
        break;
      case 'name':
        populateClaim(
          key,
          claims[key],
          "The name claim provides a human-readable value that identifies the subject of the token. The value isn't guaranteed to be unique, it can be changed, and it's designed to be used only for display purposes. The 'profile' scope is required to receive this claim.",
          claimsTable
        );
        break;
      case 'preferred_username':
        populateClaim(
          key,
          claims[key],
          'The primary username that represents the user. It could be an email address, phone number, or a generic username without a specified format. Its value is mutable and might change over time. Since it is mutable, this value must not be used to make authorization decisions. It can be used for username hints, however, and in human-readable UI as a username. The profile scope is required in order to receive this claim.',
          claimsTable
        );
        break;
      case 'nonce':
        populateClaim(
          key,
          claims[key],
          'The nonce matches the parameter included in the original /authorize request to the IDP.',
          claimsTable
        );
        break;
      case 'oid':
        populateClaim(
          key,
          claims[key],
          'The oid (user object id) is the only claim that should be used to uniquely identify a user in an Azure AD tenant.',
          claimsTable
        );
        break;
      case 'tid':
        populateClaim(
          key,
          claims[key],
          'The id of the tenant where this application resides. You can use this claim to ensure that only users from the current Azure AD tenant can access this app.',
          claimsTable
        );
        break;
      case 'upn':
        populateClaim(
          key,
          claims[key],
          'upn (user principal name) might be unique amongst the active set of users in a tenant but tend to get reassigned to new employees as employees leave the organization and others take their place or might change to reflect a personal change like marriage.',
          claimsTable
        );
        break;
      case 'email':
        populateClaim(
          key,
          claims[key],
          'Email might be unique amongst the active set of users in a tenant but tend to get reassigned to new employees as employees leave the organization and others take their place.',
          claimsTable
        );
        break;
      case 'acct':
        populateClaim(
          key,
          claims[key],
          'Available as an optional claim, it lets you know what the type of user (homed, guest) is. For example, for an individual's access to their data you might not care for this claim, but you would use this along with tenant id (tid) to control access to say a company-wide dashboard to just employees (homed users) and not contractors (guest users).',
          claimsTable
        );
        break;
      case 'sid':
        populateClaim(
          key,
          claims[key],
          'Session ID, used for per-session user sign-out.',
          claimsTable
        );
        break;
      case 'sub':
        populateClaim(
          key,
          claims[key],
          'The sub claim is a pairwise identifier - it is unique to a particular application ID. If a single user signs into two different apps using two different client IDs, those apps will receive two different values for the subject claim.',
          claimsTable
        );
        break;
      case 'ver':
        populateClaim(
          key,
          claims[key],
          'Version of the token issued by the Microsoft identity platform',
          claimsTable
        );
        break;
      case 'login_hint':
        populateClaim(
          key,
          claims[key],
          'An opaque, reliable login hint claim. This claim is the best value to use for the login_hint OAuth parameter in all flows to get SSO.',
          claimsTable
        );
        break;
      case 'idtyp':
        populateClaim(
          key,
          claims[key],
          'Value is app when the token is an app-only token. This is the most accurate way for an API to determine if a token is an app token or an app+user token',
          claimsTable
        );
        break;
      case 'uti':
      case 'rh':
        break;
      default:
        populateClaim(key, claims[key], '', claimsTable);
    }
  });

  return claimsTable;
};

/**
 * Populates claim, description, and value into an claimsObject
 * @param {String} claim
 * @param {String} value
 * @param {String} description
 * @param {Array} claimsObject
 */
const populateClaim = (
  claim: string,
  value: string,
  description: string,
  claimsTable: any[]
): void => {
  claimsTable.push({
    claim: claim,
    value: value,
    description: description,
  });
};

/**
 * Transforms Unix timestamp to date and returns a string value of that date
 * @param {number} date Unix timestamp
 * @returns
 */
const changeDateFormat = (date: number) => {
  let dateObj = new Date(date * 1000);
  return `${date} - [${dateObj.toString()}]`;
};

src/index.html을 열고 코드를 다음 코드 조각으로 바꿉니다.

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Microsoft identity platform</title>
  <base href="/">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" type="image/x-icon" href="favicon.svg">
  <link rel="preconnect" href="https://fonts.gstatic.com">
  <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500&display=swap" rel="stylesheet">
  <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
</head>
<body class="mat-typography">
  <app-root></app-root>
  <app-redirect></app-redirect>
</body>
</html>

다음 단계

3부: Angular SPA에서 인증 흐름 처리

다음을 통해 공유