Driftsättningsguide

AccessPoint använder en delad driftsättningsmodell: en lättviktig SPFx-webbdel i SharePoint, en Teams-app som är värd för samma webbdel som en personlig flik, och en Azure-backend som kör API:et och lagrar all data. Varje komponent placeras i din egen Microsoft 365-klientorganisation och Azure-prenumeration — inget hostas av utgivaren, och ingen kunddata lämnar din miljö.

Översikt

För suveräna moln/myndighetsmoln, versionslåsning eller skriptade driftsättningar publiceras alla artefakter även på https://get.realizer.io/public/accesspoint/latest/.

Installationsordningen spelar roll. Installera SharePoint-lösningen innan någon användare öppnar den personliga fliken i Teams. Teams-appen läser in SPFx-webbdelen från SharePoint i en iframe — utan den ser användarna en SharePoint 404-sida inuti Teams.

Förutsättningar

• En aktiv AccessPoint-prenumeration och API-nyckel för licensen (skaffa AccessPoint)
• En Azure-prenumeration med rollen Deltagare (eller högre) på målresursgruppen
• En SharePoint-appkatalog etablerad i din klientorganisation, samt rollen SharePoint-administratör
• Global administratör eller programadministratör i Entra ID för beviljande av Graph-behörigheter och administratörsgodkännande
• Teams-administratör (eller global administratör) för att publicera Teams-appen
• För skriptade eller manuella driftsättningar: Azure CLI (inloggad med az login som användare, inte som tjänsteprincipal) och modulen PnP.PowerShell

Det finns inget beroende av Microsoft 365-licensnivå, Power Platform eller Dataverse — vilken användare som helst med åtkomst till SharePoint eller Teams kan använda AccessPoint.

Steg 1: Driftsätt Azure-resurser

Det här steget etablerar backend: en Linux App Service (API:et), Azure SQL Database, Blob Storage och Application Insights med Log Analytics. Resurserna namnges {typ}-accesspoint-{klientnamn} (till exempel app-accesspoint-contoso) och är hårdgjorda som standard (TLS 1.3, enbart Entra-autentisering för SQL, FTPS och grundläggande autentisering avaktiverat).

Alternativ A: Azure-portalen (rekommenderas). Driftsätt AccessPoints Bicep/ARM-mall med ett klick från Azure-portalen (knappen Deploy to Azure). Driftsättningsformuläret samlar in din prenumeration och resursgrupp, klientnamn (t.ex. contoso från contoso.sharepoint.com), API-nyckel för licensen, App Service-SKU (B1 för utvärdering, S1 för standardproduktion, P1v3 som standard), en valfri e-postadress för aviseringar samt en växlingsknapp för Bevilja Graph-behörigheter (aktiverad som standard; kräver programadministratör). API-paketet driftsätts automatiskt i App Service — efter driftsättningen finns inget körtidsberoende av externa tjänster.

Alternativ B: Bicep + PowerShell. För anpassade pipelines eller strikt ändringskontroll, kör driftsättningsskriptet mot den publicerade ARM-mallen:

Invoke-WebRequest -Uri "https://get.realizer.io/public/accesspoint/latest/Deploy-AccessPoint.ps1" -OutFile "Deploy-AccessPoint.ps1"

# End-to-end: infrastruktur, konfiguration och båda apparna
.\Deploy-AccessPoint.ps1 `
    -SharePointSiteUrl "https://contoso.sharepoint.com/sites/accesspoint" `
    -TemplateUri "https://get.realizer.io/public/accesspoint/latest/main.json" `
    -DeploySharePointApp -DeployTeamsApp

Skriptet kör upp till sju steg — infrastruktur, enbart Entra-autentisering för SQL, beviljande av Graph-behörigheter, en stopp/start-cykel för App Service, SharePoints lagringsentitet (API-URL), godkännanden av SPFx API-behörigheter, samt valfri appinstallation. Varje steg kan hoppas över individuellt (-SkipInfrastructure, -SkipGraphPermissions, -SkipSharePoint). Lås en version med -ArtifactBaseUrl "https://get.realizer.io/public/accesspoint/1.0.0" för reproducerbara driftsättningar med integritetskontroll (skriptet kontrollerar den publicerade SHA-256-summan och avbryter vid avvikelse).

Kör infrastrukturdelarna själv istället:

$TenantName    = "contoso"
$ResourceGroup = "rg-accesspoint-$TenantName"

az group create --name $ResourceGroup --location "canadacentral"

$deployment = az deployment group create `
    --resource-group $ResourceGroup `
    --template-uri "https://get.realizer.io/public/accesspoint/latest/main.json" `
    --parameters tenantName=$TenantName appServiceSku=P1v3 `
    --output json | ConvertFrom-Json

$appName     = $deployment.properties.outputs.appServiceName.value
$apiUrl      = $deployment.properties.outputs.appServiceUrl.value
$principalId = $deployment.properties.outputs.appServicePrincipalId.value

# Avaktivera SQL-lösenordsautentisering — endast Entra ID (hanterad identitet)
az sql server ad-only-auth enable --resource-group $ResourceGroup `
    --server-name $deployment.properties.outputs.sqlServerName.value

Beviljande av Graph-behörigheter. App Services hanterade identitet behöver fem programbehörigheter i Microsoft Graph: Mail.Send, User.ReadBasic.All, TeamsAppInstallation.ReadForUser.All, Application.Read.All och AppCatalog.Read.All. Mallen beviljar dem automatiskt (grantGraphPermissions=true, standardvärdet) när den driftsättande användaren har rollen programadministratör eller behörigheten AppRoleAssignment.ReadWrite.All. Om inte, bevilja dem i efterhand:

$graphSpId = az ad sp show --id "00000003-0000-0000-c000-000000000000" --query id -o tsv

$permissions = @(
    @{ Name = "Mail.Send";                            Id = "b633e1c5-b582-4048-a93e-9f11b44c7e96" }
    @{ Name = "User.ReadBasic.All";                   Id = "97235f07-e226-4f63-ace3-39588e11d3a1" }
    @{ Name = "TeamsAppInstallation.ReadForUser.All"; Id = "9ce09611-f4f7-4abd-a629-a05450422a97" }
    @{ Name = "Application.Read.All";                 Id = "9a5d68dd-52b0-4cc2-bd40-abcf44ac3a30" }
    @{ Name = "AppCatalog.Read.All";                  Id = "e12dae10-5a57-4817-b79d-dfbec5348930" }
)

foreach ($perm in $permissions) {
    $bodyFile = [System.IO.Path]::GetTempFileName()
    @{ principalId = $principalId; resourceId = $graphSpId; appRoleId = $perm.Id } |
        ConvertTo-Json | Set-Content -Path $bodyFile -Encoding utf8
    az rest --method POST `
        --uri "https://graph.microsoft.com/v1.0/servicePrincipals/$principalId/appRoleAssignments" `
        --body "@$bodyFile" --headers "Content-Type=application/json" --output none
    Remove-Item $bodyFile
}

# Fullständig stopp/start (INTE omstart) rensar cacheminnet för hanterad identitets-token
az webapp stop  --name $appName --resource-group $ResourceGroup
Start-Sleep -Seconds 10
az webapp start --name $appName --resource-group $ResourceGroup

Verifiera: öppna https://<api-url>/api/health i webbläsaren och bekräfta ett friskt svar.

Steg 2: Installera AccessPoint-apparna

Installera SharePoint-lösningen först, sedan Teams-appen.

SharePoint-lösning. Från AppSource-listningen, klicka på Skaffa nu och godkänn den till din SharePoint-appkatalog, driftsatt för hela klientorganisationen. Alternativt, ladda upp manuellt (SharePoint administrationscenter > Fler funktioner > Appar > Ladda upp, markera "Gör den här lösningen tillgänglig för alla webbplatser") eller låt skriptet göra det.

Teams-app. Från AppSource-listningen, klicka på Skaffa nu och godkänn den i Teams administrationscenter, eller installera båda apparna via skriptet (den inloggade användaren behöver SharePoint-administratör samt Teams-administratör eller global administratör):

.\Deploy-AccessPoint.ps1 `
    -SharePointSiteUrl "https://contoso.sharepoint.com/sites/accesspoint" `
    -SkipInfrastructure -SkipGraphPermissions `
    -DeploySharePointApp -DeployTeamsApp

Använd INTE SharePoints "Synkronisera till Teams". Det åsidosätter tyst manifestets webApplicationInfo.id, vilket bryter aviseringar i Teams aktivitetsflöde. Ladda upp Teams-appen direkt till Teams administrationscenter.

Verifiera: lösningen visas i appkatalogen utan fel, och AccessPoint visas som Tillåten under Teams administrationscenter > Hantera appar.

Steg 3: Godkänn API-behörigheter

SPFx-paketet begär delegerade behörigheter som en SharePoint-administratör måste godkänna. I SharePoint administrationscenter, gå till Avancerat > API-åtkomst och godkänn varje väntande AccessPoint-begäran (access_as_user på AccessPoint-API:et samt Graph-omfång som User.Read.All, Sites.Read.All, Files.Read.All, Mail.Read).

Eller godkänn via PnP PowerShell:

Connect-PnPOnline -Url "https://contoso-admin.sharepoint.com" -Interactive

$spfxPermissions = @(
    @{ Resource = "ed19c96c-a7c5-4dca-8b47-0899c406329f"; Scope = "access_as_user" }
    @{ Resource = "Microsoft Graph"; Scope = "User.Read.All" }
    @{ Resource = "Microsoft Graph"; Scope = "Sites.Read.All" }
    @{ Resource = "Microsoft Graph"; Scope = "Files.Read.All" }
    @{ Resource = "Microsoft Graph"; Scope = "Mail.Read" }
)
foreach ($perm in $spfxPermissions) {
    Grant-PnPTenantServicePrincipalPermission -Scope $perm.Scope -Resource $perm.Resource
}

Slutligen beviljar en global administratör administratörsgodkännande för utgivarens app för flera klientorganisationer genom att öppna https://login.microsoftonline.com/common/adminconsent?client_id=ed19c96c-a7c5-4dca-8b47-0899c406329f i en webbläsare.

Verifiera: sidan för API-åtkomst visar inga väntande AccessPoint-begäranden.

Steg 4: Använd AccessPoint i SharePoint eller Teams

SharePoint: redigera eller skapa en sida, klicka på +, sök efter AccessPoint, lägg till webbdelen och publicera.

Teams: användare hittar AccessPoint under Appar > Byggd för din organisation (sökindexering kan ta 15 minuter upp till flera timmar efter den första installationen). Fäst den valfritt för alla via Teams administrationscenter > Principer för appinställning genom att lägga till AccessPoint under Installerade appar och Fästa appar.

Steg 5: Konfigurera API-URL:en

Öppna webbdelen och gå till Inställningar > Konfiguration. Ange API-URL:en (App Service-URL:en från steg 1, t.ex. https://app-accesspoint-contoso.azurewebsites.net) och klient-ID:t för API:ets appregistrering i Entra ID, klicka sedan på Spara. Panelen validerar HTTPS och GUID-formatet innan den sparar.

Driftsättningsskriptet ställer in den underliggande SharePoint-lagringsentiteten åt dig. Så här ställer du in den manuellt:

Connect-PnPOnline -Url "https://contoso.sharepoint.com" -Interactive
$appCatalogUrl = Get-PnPTenantAppCatalogUrl
Connect-PnPOnline -Url $appCatalogUrl -Interactive   # storage entities live on the App Catalog site

Set-PnPStorageEntity -Key "AccessPoint_ApiUrl" -Value $apiUrl -Description "AccessPoint API base URL"
Get-PnPStorageEntity -Key "AccessPoint_ApiUrl"       # verify

Verifiera: läs in webbdelen på nytt — instrumentpanelen laddas istället för konfigurationsprompten.

Steg 6: Importera ett konfigurationspaket

Gå till Inställningar > Konfigurationspaket, välj paketet för din jurisdiktion (Kanada ATIA, USA FOIA, EU GDPR med flera) och klicka på Importera. Paketet skapar begärandetyper, förlängningsskäl, valfält, aviseringsmallar och översättningar. Granska och anpassa de importerade objekten efteråt.

Steg 7: Tilldela användarroller

Den första användaren som öppnar AccessPoint tilldelas automatiskt rollerna Administratör och SAO. Gå till Inställningar > Hantera användare, klicka på Lägg till användare, sök i din katalog och tilldela roller: minst en administratör och en SAO, samt rollerna Registrator, Bidragsgivare, Granskare och Läsare vid behov.

AccessPoint är nu klart för användning.

Driftsättning för flera klientorganisationer

Använd det här mönstret när Azure-backend finns i en annan Entra ID-klientorganisation än din Microsoft 365-klientorganisation — ett delat tjänsteteam som betjänar flera affärsenheter, en MSP som hostar åt kunder, eller separata Azure/M365-klientorganisationer av styrningsskäl. En enda driftsättning kan betjäna flera M365-klientorganisationer: API:et separerar data efter klientorganisations-ID i varje användares token, med databasfrågefilter avgränsade per klientorganisation och blob-sökvägar med klientorganisationsprefix. Varje M365-klientorganisation behöver ändå sin egen licens, sin egen SPFx-driftsättning och egna godkännanden av API-behörigheter, samt sina egna Graph-autentiseringsuppgifter och aviseringsbrevlåda.

Graph-appregistrering. En hanterad identitet fungerar bara i sin hemklientorganisation, så skapa en appregistrering för en enda klientorganisation i M365-klientorganisationen (t.ex. AccessPoint Graph Connector), bevilja den samma fem Graph-programbehörigheter som anges i steg 1 med administratörsgodkännande, skapa sedan en klienthemlighet och koppla den till App Service via Key Vault:

# I M365-klientorganisationen: skapa klienthemligheten
$secret = az ad app credential reset --id $appId --display-name "AccessPoint" --years 2 --query password -o tsv

# I Azure-prenumerationen: lagra hemligheten och referera till den från App Service
az keyvault secret set --vault-name $vaultName --name "GraphClientSecret" --value $secret

az webapp config appsettings set --resource-group $ResourceGroup --name $appName --settings `
    "Graph__TenantId=$m365TenantId" `
    "Graph__ClientId=$appId" `
    "Graph__ClientSecret=@Microsoft.KeyVault(SecretUri=https://$vaultName.vault.azure.net/secrets/GraphClientSecret)"

az webapp restart --resource-group $ResourceGroup --name $appName

Lagra aldrig hemligheten direkt i App Service-inställningarna; App Services hanterade identitet behöver rollen Key Vault Secrets User på valvet. När alla tre Graph__*-inställningarna finns använder API:et appregistreringen; när de saknas faller det tillbaka på den hanterade identiteten för driftsättningar inom samma klientorganisation.

Delad brevlåda och principer för programåtkomst. Skapa en olicensierad delad brevlåda i M365-klientorganisationen för e-postaviseringar, och avgränsa Mail.Send så att appen bara kan skicka från den brevlådan:

Connect-ExchangeOnline -Organization "contoso.onmicrosoft.com"

New-Mailbox -Name "AccessPoint Notifications" -Alias "accesspoint-noreply" -Shared

New-DistributionGroup -Name "AccessPoint Mail Senders" -Type Security -ManagedBy "admin@contoso.com"
Add-DistributionGroupMember -Identity "AccessPoint Mail Senders" -Member "accesspoint-noreply@contoso.com"

New-ApplicationAccessPolicy -AppId $appId -PolicyScopeGroupId "AccessPoint Mail Senders" `
    -AccessRight RestrictAccess -Description "AccessPoint may send only from the shared mailbox"

# Verifiera (spridning kan ta upp till 30 minuter)
Test-ApplicationAccessPolicy -AppId $appId -Identity "accesspoint-noreply@contoso.com"   # expect: Granted
Test-ApplicationAccessPolicy -AppId $appId -Identity "someother@contoso.com"             # expect: Denied

Varje M365-klientorganisation upprepar sedan steg 2–5 (appar, godkännanden, API-URL — samma API-URL betjänar alla klientorganisationer). Aviseringar i Teams aktivitetsflöde kräver dessutom administratörsgodkännande för Realizers företagsapp och att Teams-appen installeras för användarna; se Grundläggande konfiguration för mer information.

Återställning och drift

Standardmekanismer i Azure täcker återställning: driftsätt om ett tidigare API-paket från historiken i App Services Deployment Center, återställ Azure SQL med tidpunktsåterställning (upp till 35 dagar), och ladda upp en tidigare versionerad .sppkg till appkatalogen igen. Import av konfigurationspaket är additiv och återställs via databasåterställning. För den fullständiga driftshandboken — detaljerade återställningsprocedurer, övervakning och underhållsuppgifter — kontakta vårt supportteam.