TeamsFx SDK

TeamsFx reduziert Ihre Aufgaben durch die Verwendung von Microsoft Teams Single Sign-On (SSO) und den Zugriff auf Cloud-Ressourcen mit einzeiligen Anweisungen und ohne Konfiguration. Sie können TeamsFx SDK sowohl im Browser als auch in Node.js Umgebungen verwenden. TeamsFx-Kernfunktionen sind in Client- und Serverumgebungen zugänglich. Sie können Benutzerauthentifizierungscode schreiben für:

• Registerkarte "Teams"
• Teams-Bot
• Azure-Funktion

Voraussetzungen

Installieren Sie die folgenden Tools, und richten Sie Ihre Entwicklungsumgebung ein:

Weitere Informationen zur Node.js Versionskompatibilität finden Sie unter Voraussetzungen für die Erstellung Ihrer Teams-App mit Visual Studio Code.

Sie müssen über praktische Kenntnisse in folgenden Bereichen verfügen:

• Quellcode
• Paket (NPM)
• API-Referenzdokumentation
• Beispiele

Erste Schritte

Das TeamsFx SDK ist im Gerüstprojekt mithilfe der Microsoft 365 Agents Toolkit CLI (früher als TeamsFx Toolkit oder CLI bezeichnet) vorkonfiguriert. Weitere Informationen finden Sie unter Teams-App-Projekt.

Paket installieren

"Install from" (Installieren @microsoft/m365agentstoolkit-cli ) npm und "Ausführen atk -h ", um alle verfügbaren Befehle zu überprüfen:

npm install -g @microsoft/m365agentstoolkit-cli
atk -h

TeamsFx-Kernfunktionalitäten

TeamsFx-Klasse

Die TeamsFx-Klassen-instance greift standardmäßig über die Umgebungsvariablen auf alle TeamsFx-Einstellungen zu. Sie können benutzerdefinierte Konfigurationswerte festlegen, um die Standardwerte zu überschreiben. Weitere Informationen finden Sie unter Außerkraftsetzungskonfiguration für Details. Wenn Sie eine TeamsFx-Instance erstellen, müssen Sie den Identitätstyp angeben.

Die folgende Liste enthält die zwei verschiedenen Arten von Identitäten:

• Benutzeridentität: Stellt den aktuellen Benutzer von Teams dar.
• Anwendungsidentität: Stellt die Anwendung selbst dar.

Weitere Informationen zur Benutzeridentität und Anwendungsidentität finden Sie im folgenden Abschnitt:

Anmeldeinformationen

Anmeldeinformationsklassen implementieren die Schnittstelle, die TokenCredential häufig in Azure-Bibliotheks-APIs verwendet wird, um Zugriffstoken für bestimmte Bereiche bereitzustellen. Weitere Informationen zu Klassen im Zusammenhang mit Anmeldeinformationen und Authentifizierungsflüssen finden Sie im Ordner für Anmeldeinformationen.

Zur Vereinfachung der Authentifizierung gibt es drei Klassen von Anmeldeinformationen. Im Folgenden finden Sie die entsprechenden Szenarien für jedes Qualifikationsklassenziel:

const authConfig: TeamsUserCredentialAuthConfig = {
  clientId: process.env.REACT_APP_CLIENT_ID,
  initiateLoginEndpoint: process.env.REACT_APP_START_LOGIN_PAGE_URL,
};

const credential = new TeamsUserCredential(authConfig);

const oboAuthConfig: OnBehalfOfCredentialAuthConfig = {
  authorityHost: process.env.M365_AUTHORITY_HOST,
  clientId: process.env.M365_CLIENT_ID,
  tenantId: process.env.M365_TENANT_ID,
  clientSecret: process.env.M365_CLIENT_SECRET,
};

const oboCredential = new OnBehalfOfUserCredential(ssoToken, oboAuthConfig);

const appAuthConfig: AppCredentialAuthConfig = {
  authorityHost: process.env.M365_AUTHORITY_HOST,
  clientId: process.env.M365_CLIENT_ID,
  tenantId: process.env.M365_TENANT_ID,
  clientSecret: process.env.M365_CLIENT_SECRET,
};
const appCredential = new AppCredential(appAuthConfig);

Bot-SSO

Bot-bezogene Klassen werden im Bot-Ordner gespeichert.

TeamsBotSsoPrompt Integration in das Botframework. Es vereinfacht den Authentifizierungsprozess, wenn Sie eine Bot-Anwendung entwickeln und das Bot-SSO verwenden möchten.

Der folgende Code ist ein Beispiel für die Erstellung TeamsBotSsoPrompt:

const TeamsBotSsoPromptId = "TEAMS_BOT_SSO_PROMPT";

const settings: TeamsBotSsoPromptSettings = {
  scopes: ["User.Read"],
  timeout: 900000,
  endOnInvalidMessage: true,
};

const authConfig: OnBehalfOfCredentialAuthConfig = {
  authorityHost: process.env.M365_AUTHORITY_HOST,
  clientId: process.env.M365_CLIENT_ID,
  tenantId: process.env.M365_TENANT_ID,
  clientSecret: process.env.M365_CLIENT_SECRET,
};
const loginUrl = process.env.INITIATE_LOGIN_ENDPOINT;
const ssoPrompt = new TeamsBotSsoPrompt(authConfig, loginUrl, TeamsBotSsoPromptId, settings);

Unterstützte Funktionen

TeamsFx SDK bietet mehrere Funktionen zur Vereinfachung der Konfiguration für Bibliotheken von Drittanbietern. Sie befinden sich im Kernordner.

• Microsoft Graph Service: createMicrosoftGraphClient, createMicrosoftGraphClientWithCredentialund MsGraphAuthProvider Hilfe beim Erstellen einer authentifizierten Graph-instance.

• SQL: Das getTediousConnectionConfig gibt eine mühsame Verbindungskonfiguration zurück.

  Erforderliche Konfiguration:

  • Wenn Sie die Benutzeridentität verwenden möchten, dann sqlServerEndpointsind , sqlUsername, und sqlPassword erforderlich.
  • Wenn Sie die MSI-Identität verwenden möchten, dann sqlServerEndpoint und sqlIdentityId sind erforderlich.

Außerkraftsetzung der Konfiguration für TeamsFx-Klasse

Sie können beim Erstellen einer neuen TeamsFx Instance eine benutzerdefinierte Konfiguration übergeben, um die Standardkonfiguration außer Kraft zu setzen oder erforderliche Felder festzulegen, wenn environment variables diese fehlen.

Fehlerbehandlung

Der grundlegende Typ der API-Fehlerantwort ist ErrorWithCode, der Fehlercode und Fehlermeldung enthält. Um beispielsweise einen bestimmten Fehler herauszufiltern, können Sie den folgenden Codeausschnitt verwenden:

try {
  const atk = new TeamsFx();
  await teamsfx.login("User.Read");
} catch (err: unknown) {
  if (err instanceof ErrorWithCode && err.code !== ErrorCode.ConsentFailed) {
    throw err;
  } else {
    // Silently fail because user cancels the consent dialog
    return;
  }
}

try {
  const authConfig: TeamsUserCredentialAuthConfig = {
    clientId: process.env.REACT_APP_CLIENT_ID,
    initiateLoginEndpoint: process.env.REACT_APP_START_LOGIN_PAGE_URL,
  };

  const credential = new TeamsUserCredential(authConfig);  
  await credential.login("User.Read");
} catch (err: unknown) {
  if (err instanceof ErrorWithCode && err.code !== ErrorCode.ConsentFailed) {
    throw err;
  } else {
    // Silently fail because user cancels the consent dialog
    return;
  }
}

Wenn eine Credential-Instance in einer anderen Bibliothek, z. B. Microsoft Graph, verwendet wird, ist es möglich, dass ein Fehler abgefangen und transformiert wird.

Microsoft Graph-Szenarien

Dieser Abschnitt enthält mehrere Codeausschnitte für häufige Szenarien im Zusammenhang mit Microsoft Graph. In solchen Szenarien kann der Benutzer APIs mit unterschiedlichen Berechtigungen im Front-End oder Backend aufrufen.

• Benutzer-Stellvertretungsberechtigung im Frontend (Verwenden TeamsUserCredential)

  Verwenden der Graph-API in der Registerkarten-App

  Dieser Codeausschnitt zeigt Ihnen, wie Sie Benutzerprofile von Microsoft Graph in der Registerkarten-App verwenden TeamsUserCredential und createMicrosoftGraphClientWithCredential abrufen. Außerdem wird gezeigt, wie Sie einen .GraphError

  1. Importieren Sie die benötigten Klassen.

     import {
      createMicrosoftGraphClientWithCredential,
      TeamsUserCredential,
     } from "@microsoft/teamsfx";
     

  2. instance erstellen TeamsUserCredential .

     const authConfig: TeamsUserCredentialAuthConfig = {
     clientId: process.env.REACT_APP_CLIENT_ID!,
     initiateLoginEndpoint: process.env.REACT_APP_START_LOGIN_PAGE_URL!,
     };
     
     const teamsUserCredential = new TeamsUserCredential(authConfig);
     

  3. Verwenden Sie diese Methode teamsUserCredential.login() , um die Zustimmung des Benutzers einzuholen.

     // Put these code in a call-to-action callback function to avoid browser blocking automatically showing up pop-ups.
     await teamsUserCredential.login(["User.Read"]); // Login with scope
     

  4. Sie können eine TeamsFx-Instance und einen Graph-Client initialisieren und Informationen von Microsoft Graph über diesen Client abrufen.

     try {
      const graphClient = createMicrosoftGraphClientWithCredential(teamsUserCredential, ["User.Read"]); // Initializes MS Graph SDK using our MsGraphAuthProvider
      const profile = await graphClient.api("/me").get();
     } catch (err: unknown) {
      // ErrorWithCode is handled by Graph client
      if (err instanceof GraphError && err.code?.includes(ErrorCode.UiRequiredError)) {
        // Need to show login button to ask for user consent.
      }
     }
     

  Weitere Informationen zum Beispiel für die Verwendung der Graph-API in der Registerkarten-App finden Sie im Beispiel für die Graph Conector App.

  Integration mit dem Microsoft Graph-Toolkit

  Die Microsoft Graph-Toolkit-Bibliothek ist eine Sammlung verschiedener Authentifizierungsanbieter und Benutzeroberflächenkomponenten, die von Microsoft Graph unterstützt werden.

  Das @microsoft/mgt-teamsfx-provider Paket macht die Klasse verfügbar, die TeamsFxProvider die Klasse zum Anmelden von Benutzern und zum Abrufen von Token zur Verwendung mit Microsoft Graph verwendet TeamsFx .

  1. Sie können die folgenden erforderlichen Pakete installieren:

        npm install @microsoft/mgt-element @microsoft/mgt-teamsfx-provider @microsoft/teamsfx
     

  2. Initialisieren Sie den Anbieter innerhalb Ihrer Komponente.

     // Import the providers and credential at the top of the page
     import {Providers} from '@microsoft/mgt-element';
     import {TeamsFxProvider} from '@microsoft/mgt-teamsfx-provider';
     import {TeamsUserCredential} from "@microsoft/teamsfx";
     
     const scope = ["User.Read"];
     const atk = new TeamsFx();
     const provider = new TeamsFxProvider(teamsfx, scope);
     Providers.globalProvider = provider;   
     

  3. Sie können die teamsfx.login(scopes) Methode verwenden, um das erforderliche Zugriffstoken abzurufen.

     // Put these code in a call-to-action callback function to avoid browser blocking automatically showing up pop-ups. 
     await teamsfx.login(this.scope);
     Providers.globalProvider.setState(ProviderState.SignedIn);
     

  4. Sie können eine beliebige Komponente in Ihre HTML-Seite oder in Ihre render() Methode mit React einfügen, um den TeamsFx Kontext für den Zugriff auf Microsoft Graph zu verwenden.

     <mgt-person query="me" view="threeLines"></mgt-person>
     

     public render(): void {
     return (
      <div>
          <Person personQuery="me" view={PersonViewType.threelines}></Person>
      </div>
     );
     }    
     

  Weitere Informationen zum Beispiel zur Initialisierung des TeamsFx-Anbieters finden Sie im Beispiel für den Export von Kontakten.

• Benutzer-Stellvertretungsberechtigung im Backend (Verwenden OnBehalfOfUserCredential)

  Verwenden der Graph-API in der Bot-Anwendung

  Dieser Codeausschnitt zeigt Ihnen, wie TeamsBotSsoPrompt Sie ein Dialogfeld festlegen und sich dann anmelden, um ein Zugriffstoken zu erhalten.

  1. Initialisieren und zum Dialogsatz hinzufügen TeamsBotSsoPrompt .

     const { ConversationState, MemoryStorage } = require("botbuilder");
     const { DialogSet, WaterfallDialog } = require("botbuilder-dialogs");
     const { TeamsBotSsoPrompt, OnBehalfOfCredentialAuthConfig, TeamsBotSsoPromptSettings } = require("@microsoft/teamsfx");
     
     const convoState = new ConversationState(new MemoryStorage());
     const dialogState = convoState.createProperty("dialogState");
     const dialogs = new DialogSet(dialogState);
     
     const TeamsBotSsoPromptId = "TEAMS_BOT_SSO_PROMPT";
     
     const settings: TeamsBotSsoPromptSettings = {
     scopes: ["User.Read"],
     timeout: 900000,
     endOnInvalidMessage: true,
     };
     
     const authConfig: OnBehalfOfCredentialAuthConfig = {
      authorityHost: process.env.M365_AUTHORITY_HOST,
      clientId: process.env.M365_CLIENT_ID,
      tenantId: process.env.M365_TENANT_ID,
      clientSecret: process.env.M365_CLIENT_SECRET,
     };
     const loginUrl = process.env.INITIATE_LOGIN_ENDPOINT;
     const ssoPrompt = new TeamsBotSsoPrompt(authConfig, loginUrl, TeamsBotSsoPromptId, settings);
     
     dialogs.add(ssoPrompt);    
     

  2. Starten Sie das Dialogfeld, und melden Sie sich an.

     dialogs.add(
       new WaterfallDialog("taskNeedingLogin", [
        async (step) => {
          return await step.beginDialog("TeamsBotSsoPrompt");
        },
        async (step) => {
         const token = step.result;
         if (token) {
           // ... continue with task needing access token ...
         } else {
          await step.context.sendActivity(`Sorry... We couldn't log you in. Try again later.`);
          return await step.endDialog();
         }
       },
      ])
     );    
     

  Weitere Informationen zur Verwendung der Graph-API in einer Bot-Anwendung finden Sie im Bot-SSO-Beispiel.

  Verwenden der Graph-API in der Nachrichtenerweiterung

  Der folgende Codeausschnitt veranschaulicht, wie das überschrieben handleTeamsMessagingExtensionQuerywird, das von TeamsActivityHandlerreicht. Es verwendet handleMessageExtensionQueryWithSSO das TeamsFx SDK, das vom TeamsFx SDK bereitgestellt wird, um sich anzumelden und ein Zugriffstoken abzurufen:

  
   const authConfig: OnBehalfOfCredentialAuthConfig = {
    authorityHost: process.env.M365_AUTHORITY_HOST,
    clientId: process.env.M365_CLIENT_ID,
    tenantId: process.env.M365_TENANT_ID,
    clientSecret: process.env.M365_CLIENT_SECRET,
   };
   const loginUrl = process.env.INITIATE_LOGIN_ENDPOINT;
   public async handleTeamsMessagingExtensionQuery(context: TurnContext, query: any): Promise<any> {
    return await handleMessageExtensionQueryWithSSO(context, authConfig, loginUrl, 'User.Read', 
      async (token: MessageExtensionTokenResponse) => {
        // ... continue to query with access token ...
      });
   }    
  

  Weitere Informationen zur Verwendung der Graph-API in einer Nachrichtenerweiterung finden Sie im Beispiel message-extension-sso.

  Verwenden Sie die Graph-API im Befehlsbot

  Dieser Codeausschnitt veranschaulicht, wie TeamsFxBotSsoCommandHandler ein Befehlsbot implementiert, um die Microsoft-API aufzurufen.

   import { Activity, TurnContext } from "botbuilder";
   import {
    CommandMessage,
    TriggerPatterns,
    createMicrosoftGraphClientWithCredential,
    TeamsFxBotSsoCommandHandler,
    TeamsBotSsoPromptTokenResponse,
   } from "@microsoft/teamsfx";
  
   const authConfig: OnBehalfOfCredentialAuthConfig = {
    authorityHost: process.env.M365_AUTHORITY_HOST,
    clientId: process.env.M365_CLIENT_ID,
    tenantId: process.env.M365_TENANT_ID,
    clientSecret: process.env.M365_CLIENT_SECRET,
   };
   const loginUrl = process.env.INITIATE_LOGIN_ENDPOINT;
  
   export class ProfileSsoCommandHandler implements TeamsFxBotSsoCommandHandler {
    triggerPatterns: TriggerPatterns = "profile";
  
    async handleCommandReceived(
      context: TurnContext,
      message: CommandMessage,
      tokenResponse: TeamsBotSsoPromptTokenResponse,
    ): Promise<string | Partial<Activity> | void> {
  
      const oboCredential = new OnBehalfOfUserCredential(tokenResponse.ssoToken, oboAuthConfig);
  
      // Add scope for your Azure AD app. For example: Mail.Read, etc.
      const graphClient = createMicrosoftGraphClientWithCredential(oboCredential, ["User.Read"]);
  
      // Call Graph API using `graph` instance to get user profile information
      const me = await graphClient.api("/me").get();
  
      if (me) {
        // Bot will send the user profile info to user
        return `Your command is '${message.text}' and you're logged in as ${me.displayName}`;
      } else {
        return "Could not retrieve profile information from Microsoft Graph.";
      }
    }
   }    
  
  

  Weitere Informationen zum Implementieren eines SSO-Befehlshandlers in einem Befehlsbot finden Sie unter Hinzufügen von einmaligem Anmelden zur Teams-App. Es gibt auch ein command-bot-with-sso-Beispielprojekt , das Sie für den SSO-Befehlsbot ausprobieren können.

  Call Azure Function in tab app: On-Behalf-Of-Flow

  Dieser Codeausschnitt veranschaulicht, wie Sie die axios Bibliothek verwendenCreateApiClient, um eine Azure-Funktion aufzurufen, und wie Sie die Graph-API in einer Azure-Funktion aufrufen, um Benutzerprofile abzurufen.

  1. Zum Aufrufen einer Azure-Funktion können CreateApiClient Sie die vom TeamsFx-SDK bereitgestellte Funktion verwenden:

     async function callFunction() {
       const authConfig: TeamsUserCredentialAuthConfig = {
      clientId: process.env.REACT_APP_CLIENT_ID,
      initiateLoginEndpoint: process.env.REACT_APP_START_LOGIN_PAGE_URL,
       };
      const teamsUserCredential = new TeamsUserCredential(authConfig);
      // Create an API client by providing the token and endpoint.
      const apiClient = CreateApiClient(
        "https://YOUR_API_ENDPOINT", // Create an API Client that uses SSO token to authenticate requests
        new BearerTokenAuthProvider(async () =>  (await teamsUserCredential.getToken(""))!.token) // Call API hosted in Azure Functions on behalf of user to inject token to request header
      );
      // Send a GET request to "RELATIVE_API_PATH", "/api/functionName" for example.
       const response = await apiClient.get("RELATIVE_API_PATH");
       return response.data;
     }    
     

     Sie können die axios Bibliothek auch verwenden, um eine Azure Function aufzurufen.

     async function callFunction() {
       const authConfig: TeamsUserCredentialAuthConfig = {
         clientId: process.env.REACT_APP_CLIENT_ID,
         initiateLoginEndpoint: process.env.REACT_APP_START_LOGIN_PAGE_URL,
       };
       const teamsUserCredential = new TeamsUserCredential(authConfig);
       const accessToken = await teamsUserCredential.getToken(""); // Get SSO token 
       const endpoint = "https://YOUR_API_ENDPOINT";
       const response = await axios.default.get(endpoint + "/api/" + functionName, {
         headers: {
           authorization: "Bearer " + accessToken.token,
         },
       });
       return response.data;
     }    
     
     

  2. Rufen Sie als Antwort die Graph-API in einer Azure-Funktion im Namen des Benutzers auf.

     
     export default async function run(
     context: Context,
     req: HttpRequest,
     teamsfxContext: TeamsfxContext
     ): Promise<Response> {
      const res: Response = { status: 200, body: {},};
     
      const authConfig: OnBehalfOfCredentialAuthConfig = {
        authorityHost: process.env.M365_AUTHORITY_HOST,
        clientId: process.env.M365_CLIENT_ID,
        tenantId: process.env.M365_TENANT_ID,
        clientSecret: process.env.M365_CLIENT_SECRET,
      };
      const oboCredential = new OnBehalfOfUserCredential(tokenResponse.ssoToken, oboAuthConfig);
     
      // Query user's information from the access token.
      try {
       const currentUser: UserInfo = await oboCredential.getUserInfo();
       if (currentUser && currentUser.displayName) {
         res.body.userInfoMessage = `User display name is ${currentUser.displayName}.`;
       } else {
         res.body.userInfoMessage = "No user information was found in access token.";
       }
      } catch (e) {
      }
      // Create a graph client to access user's Microsoft 365 data after user has consented.
      try {
       const graphClient: Client = createMicrosoftGraphClientWithCredential(oboCredential, [".default"]);
       const profile: any = await graphClient.api("/me").get();
       res.body.graphClientMessage = profile;
      } catch (e) {
      }
      return res;
      }
     
     

  Weitere Informationen zur Verwendung der Graph-API in einer Bot-Anwendung finden Sie im Beispiel hello-world-tab-with-backend.

• Anwendungsberechtigung im Back-End

  Verwenden der zertifikatbasierten Authentifizierung in der Azure-Funktion

  Dieser Codeausschnitt veranschaulicht, wie Sie die zertifikatbasierte Anwendungsberechtigung verwenden, um das Token abzurufen, das zum Aufrufen der Graph-API verwendet werden kann.

  1. Sie können das appAuthConfig initialisieren, indem Sie eine PEM-encoded key certificate.

      const appAuthConfig: AppCredentialAuthConfig = {
        authorityHost: process.env.M365_AUTHORITY_HOST,
        clientId: process.env.M365_CLIENT_ID,
        tenantId: process.env.M365_TENANT_ID,
        certificateContent: 'PEM-encoded key certificate',
       };
     
     

  2. Sie können verwenden AppCredential , um das Token abzurufen.

     const appCredential = new AppCredential(appAuthConfig);
     const token = appCredential.getToken();    
     

  Verwenden der Authentifizierung mit geheimem Clientschlüssel in der Azure-Funktion

  Dieser Codeausschnitt veranschaulicht, wie Sie die Anwendungsberechtigung des geheimen Clientschlüssels verwenden, um das Token abzurufen, das zum Aufrufen der Graph-API verwendet wird.

  1. Sie können das authConfig initialisieren, indem Sie eine client secret.

     const appAuthConfig: AppCredentialAuthConfig = {
      authorityHost: process.env.M365_AUTHORITY_HOST,
      clientId: process.env.M365_CLIENT_ID,
      tenantId: process.env.M365_TENANT_ID,
      clientSecret: process.env.M365_CLIENT_SECRET,
     };
     

  2. Sie können diese authConfig verwenden, um das Token abzurufen.

     const appCredential = new AppCredential(appAuthConfig);
     const token = appCredential.getToken();    
     

  Weitere Informationen zur Verwendung der Graph-API in einer Bot-Anwendung finden Sie im Beispiel hello-world-tab-with-backend.

Andere Szenarien

Dieser Abschnitt enthält mehrere Codeausschnitte für andere Szenarien im Zusammenhang mit Microsoft Graph. Sie können einen API-Client in einer Bot- oder Azure-Funktion erstellen und auf eine SQL-Datenbank in einer Azure-Funktion zugreifen.

// Create an API Key auth provider. In addition to ApiKeyProvider, the following auth providers are also available:
// BearerTokenAuthProvider, BasicAuthProvider, CertificateAuthProvider.
const authProvider = new ApiKeyProvider("YOUR_API_KEY_NAME",
  "YOUR_API_KEY_VALUE",
  ApiKeyLocation.Header
);

// Create an API client using the above auth provider.
// You can also implement the AuthProvider interface and use it here.
const apiClient = createApiClient(
  "YOUR_API_ENDPOINT",
  authProvider
);

// Send a GET request to "RELATIVE_API_PATH", "/api/apiname" for example.
const response = await apiClient.get("RELATIVE_API_PATH");  

Erweiterte Anpassung

Protokoll konfigurieren

Sie können die Kundenprotokollebene und die Umleitungsausgaben festlegen, wenn Sie diese Bibliothek verwenden.

Aktivieren des Protokolls durch Festlegen der Protokollebene

Wenn Sie die Protokollebene festlegen, wird die Protokollierung aktiviert. Standardmäßig werden Protokollinformationen in der Konsole ausgegeben.

Legen Sie die Protokollebene mithilfe des folgenden Codeausschnitts fest:

// Only need the warning and error messages.
setLogLevel(LogLevel.Warn);

Umleiten durch Festlegen einer benutzerdefinierten Protokollierung

setLogLevel(LogLevel.Info);
// Set another logger if you want to redirect to Application Insights in Azure Function
setLogger(context.log);

Umleiten durch Festlegen einer benutzerdefinierten Protokollfunktion

setLogLevel(LogLevel.Info);
// Only log error messages to Application Insights in bot application.
setLogFunction((level: LogLevel, message: string) => {
  if (level === LogLevel.Error) {
    this.telemetryClient.trackTrace({
      message: message,
      severityLevel: Severity.Error,
    });
  }
});

Aktualisieren auf die neueste SDK-Version

Wenn Sie die Version des SDK verwenden, die über loadConfiguration()verfügt, können Sie die folgenden Schritte ausführen, um ein Upgrade auf die neueste SDK-Version durchzuführen:

1. Anstatt loadConfiguration(), verwenden Sie die spezifischen Authentifizierungskonfigurationsklassen, um die Einstellungen für die einzelnen Anmeldeinformationstypen anzupassen. Verwenden Sie AppCredentialAuthConfig z. B. für AppCredential, OnBehalfOfUserCredentialAuthConfig für OnBehalfOfUserCredentialund TeamsUserCredentialAuthConfig für TeamsUserCredential.
2. Ersetzen new TeamsUserCredential() durch new TeamsUserCredential(authConfig).
3. Ersetzen new M365TenantCredential() durch new AppCredential(authConfig).
4. Ersetzen new OnBehalfOfUserCredential(ssoToken) durch new OnBehalfOfUserCredential(authConfig).

Siehe auch

• Übersicht über das Microsoft 365 Agents-Toolkit
• Microsoft 365 Agents Toolkit CLI
• Microsoft TeamsFx-Beispielkatalog.
• Einmaliges Anmelden für die Teams-App hinzufügen