Skip to Content
Cloud Engineering Academy
13. Microsoft-to-AWS Migration

Monitoring and identity side by side: Azure Monitor and Entra ID vs AWS

Translate Azure Monitor, Application Insights, KQL and Log Analytics into CloudWatch, Logs Insights and OpenTelemetry, and map Entra ID, Active Directory and managed identities onto IAM Identity Center, Cognito, AWS Managed Microsoft AD and IAM roles, with four identity integration patterns for a bank.

advanced⏱ 1 h 45 min🟢 FreeSOA-C03SCS-C03SAP-C03

Assumes: .NET 10 LTS · OpenTelemetry .NET · AWS Distro for OpenTelemetry (ADOT) · AWS SDK for .NET v4 · AWS CLI v2 · Region us-east-1. Verified against official sources on 2026-11-18.

Learning objectives

By the end of this lesson you can:

  • Map Azure Monitor, Application Insights, Log Analytics and Activity Log onto CloudWatch, Logs Insights, X-Ray or OpenTelemetry, and CloudTrail.
  • Translate three common KQL queries into CloudWatch Logs Insights queries.
  • Replace the Application Insights SDK with OpenTelemetry in an ASP.NET Core service so telemetry is portable.
  • Map Entra ID, Active Directory Domain Services, Conditional Access and managed identities to their AWS counterparts.
  • Choose among four identity integration patterns for workforce and customer sign-in, and name the failure mode of each.

Prerequisites

Why this matters in banking

Two things decide whether a migrated platform is operable: can the on-call engineer see what is happening, and can the right people (and only them) get in. At Harbourline, on-call engineers have years of KQL muscle memory and a workbook per service. If the first production incident on AWS finds them searching documentation for a query syntax, mean time to recovery doubles. Identity has the same risk with higher stakes: the bank's staff sign in with Entra ID, with Conditional Access rules, privileged role elevation and quarterly access reviews. A migration that leaves AWS access in a spreadsheet of IAM users fails the next access review and, worse, leaves leavers with working credentials.

This lesson shows how to carry observability habits and identity governance across.

The idea in plain language

Monitoring answers "is it healthy, and if not, why?" with three kinds of data: metrics (numbers over time), logs (event records) and traces (the path of one request across services). Identity answers "who is this, and what may they do?" for two populations: workforce (staff) and customers.

  • On Azure, Azure Monitor collects metrics and logs, Log Analytics stores logs and runs KQL, and Application Insights adds application telemetry and tracing. Entra ID is the identity provider for staff, and managed identities are the identities of workloads.
  • On AWS, CloudWatch holds metrics, logs, alarms and dashboards; X-Ray (backend) and OpenTelemetry carry traces; CloudTrail records control-plane activity. IAM Identity Center gives staff access to accounts; Cognito handles customer sign-in; IAM roles are workload identities.

Analogy: monitoring is the bank's CCTV and alarm panel; identity is the staff pass system. Moving buildings, you do not buy new cameras that only work with one vendor's recorders (use open standards: OpenTelemetry), and you do not issue new passes by hand (federate the existing staff directory).

What problem the AWS services solve

ServiceProblemLimits and sharp edges
CloudWatch Metrics and AlarmsNumeric health signals with thresholds and anomaly detectionCustom metrics are billed; high-cardinality dimensions get expensive
CloudWatch Logs + Logs InsightsCentral log storage with interactive queriesBilled by ingestion and storage; set retention, the default is never expire
CloudWatch Application SignalsService-level SLOs and application maps built from OpenTelemetry dataSee the Application Signals lesson
X-RayTrace storage and service mapThe X-Ray SDKs and daemon entered maintenance mode on 2026-02-25; use OpenTelemetry (ADOT) and keep X-Ray as the backend
CloudTrailWho called which AWS API, whenManagement events on by default (90-day history); a trail to S3 is needed for long retention
IAM Identity CenterWorkforce single sign-on and per-account permission setsOne instance per organisation; changing the identity source removes assignments, so export them first
Cognito user poolsCustomer sign-up, sign-in, MFA, federationToken shapes differ from Entra ID (see the code section)
AWS Managed Microsoft ADA real AD (Windows Server domain controllers) in AWS for Windows workloadsHourly cost per directory; a trust to on-premises AD is optional
AD ConnectorProxy that forwards sign-ins to on-premises ADDepends on the connection to on-premises; not a directory itself

Service availability note. AWS Directory Service Simple AD is in maintenance (announced 2026-06-30); do not plan new designs on it. Use AWS Managed Microsoft AD or AD Connector. ⚠ VERIFY on the AWS service lifecycle page before design sign-off.

Microsoft / Azure comparison

Monitoring

You know (Azure)AWS equivalentWhat's different
Azure Monitor metricsCloudWatch metricsNamespaces and dimensions instead of resource scopes; standard metrics are free, custom are billed
Log Analytics workspaceCloudWatch log groups (and Logs Insights)No single workspace: log groups per service; cross-account observability links accounts
KQLLogs Insights query language; CloudWatch also supports OpenSearch PPL and SQL in Logs InsightsThree query languages; PPL and SQL were added in December 2024 (docs)
Alerts and action groupsCloudWatch alarms with SNS, EventBridge or Systems Manager actionsAn alarm has states (OK, ALARM, INSUFFICIENT_DATA); add composite alarms for noisy services
Workbooks, dashboardsCloudWatch dashboards, Quick Sight for business reportingDashboards are JSON and can be code-managed
Application Insights (APM)Application Signals, X-Ray traces, OpenTelemetryCloudWatch also has a separate feature named "Application Insights" for detecting problems in common stacks; do not confuse them
Availability testsCloudWatch Synthetics canariesCanaries are Lambda-based scripts you pay for per run
Live metrics, ProfilerCloudWatch Application Signals, CodeGuru Profiler (check status) ⚠ VERIFYVerify service status before design
Activity LogCloudTrailShip to S3 and an organisation trail for evidence
Diagnostic settingsLog group settings, subscription filters, Firehose, S3 exportMany AWS services log to CloudWatch Logs or S3 when you enable it
Smart detectionAnomaly detection alarmsTrain on a baseline of days to weeks

Three KQL queries in Logs Insights

QuestionKQLLogs Insights
Errors per 5 minutestraces | where severityLevel >= 3 | summarize count() by bin(timestamp, 5m)filter level = "Error" | stats count(*) by bin(5m)
Slowest endpointsrequests | summarize p95 = percentile(duration, 95) by name | top 5 by p95 descstats pct(durationMs, 95) as p95 by route | sort p95 desc | limit 5
Find one requestunion * | where operation_Id == "abc123"fields @timestamp, @message | filter traceId = "abc123" | sort @timestamp asc

Field names such as level and durationMs come from your JSON logs; Logs Insights discovers fields in JSON automatically, which is why the earlier lesson set up JSON console logging.

Identity

You know (Microsoft)AWS equivalentWhat's different
Entra ID tenant (workforce)IAM Identity Center with Entra ID as the external identity providerIdentity Center is the AWS front door; Entra stays the directory
Entra groups assigned to subscriptionsGroups assigned to permission sets per accountAssignments are per account and per permission set
Conditional Access (device, location, risk)Enforced in Entra ID before the SAML sign-in; on AWS, IAM conditions and SCPs add network or tag limitsKeep device and location policy in Entra; AWS enforces what the session may do
PIM (just-in-time elevation)Time-boxed permission set assignment through an access request workflowIdentity Center has no built-in approval workflow; many banks add a request tool ⚠ VERIFY current native options
Entra External ID / B2C (customers)Cognito user poolsDifferent token claims and flows; plan app changes
App registration and service principalCognito app client; for workloads, an IAM roleMachine-to-machine on AWS means IAM roles, not client secrets
System-assigned managed identityIAM role on EC2, ECS task or LambdaYou create and name the role
Active Directory Domain ServicesAWS Managed Microsoft AD (or self-managed AD on EC2)A real domain controller fleet managed by AWS across two AZs
Entra Domain ServicesAWS Managed Microsoft ADSimilar managed-domain role
AD FSFederation directly from Entra or the IdP to Identity Center or IAM SAMLAD FS is no longer required for AWS sign-in
Group PolicyStill GPO on Managed AD for Windows serversUnchanged for domain-joined EC2
Entra access reviewsReview Identity Center assignments and IAM Access Analyzer findingsExport assignments for the review; Access Analyzer finds unused access

Architecture

Four identity integration patterns. Most banks use A for staff, B for Windows workloads, C during transition and D for customers.

Security-boundary view. In Pattern A, the strongest control sits in Entra: MFA and Conditional Access happen before AWS ever sees the user. AWS sees only a SAML assertion and issues a short session for a permission set. In Pattern B, domain controllers are in your private subnets, reachable only from your VPCs and through the trust link; the trust direction matters (see mistakes below).

Failure modes. A: SCIM drift leaves a leaver's access in place until the next sync; keep a revocation drill. B: if the link to on-premises drops, accounts present only on-premises cannot authenticate. C: Connector depends entirely on on-premises availability. D: token claim differences break APIs written for Entra tokens.

Step-by-step implementation

Inventory what you observe and who signs in

List dashboards, alerts, KQL queries in use, retention, and who reads them. For identity, list directories, groups, privileged roles, service principals, Conditional Access policies and access review cycles.

Choose the identity pattern

Apply the four patterns. Almost every Azure estate starts with Pattern A for staff; add B if Windows servers or RDS for SQL Server must use Windows authentication.

Connect Entra ID to Identity Center

Follow AWS's guide for SAML and SCIM with Entra ID (guide). Create the enterprise application, exchange metadata, enable automatic provisioning, assign groups, then create permission sets and assign groups to accounts. Check how nested groups and attribute removal behave before relying on them ⚠ VERIFY.

Instrument one service with OpenTelemetry

Replace the Application Insights SDK with OpenTelemetry in a single service, send OTLP to an ADOT collector (a sidecar or an agent), and compare traces with the old ones.

Rebuild alerts as code

Convert each critical Azure alert rule to a CloudWatch alarm in IaC with a documented runbook link and an owner. Set log retention in the same stack.

Parallel run

Keep Azure Monitor alerts on for the same workloads until AWS alarms have fired correctly in game-day tests.

AWS Console instructions

  • Logs Insights: Console → CloudWatch → Logs → Logs Insights, select log groups, choose the query language (Logs Insights QL, OpenSearch PPL or SQL) and run.
  • Alarm: Console → CloudWatch → Alarms → Create alarm → Select metric, set the threshold, then Add notification to an SNS topic.
  • Identity Center: Console → IAM Identity Center → Settings → Identity source → Actions → Change identity source → External identity provider. Warning: changing the identity source (to or from Active Directory in particular) can remove existing assignments, so export them first.
  • Directory: Console → Directory Service → Set up directory → AWS Managed Microsoft AD (design-only in the lab: it is billed hourly).

AWS CLI

# Run a Logs Insights query over the last hour (replace the log group). Returns a query ID first.
QID=$(aws logs start-query --log-group-name /hl/m13/rates-api \
  --start-time $(date -d '-1 hour' +%s) --end-time $(date +%s) \
  --query-string 'filter level = "Error" | stats count(*) by bin(5m)' \
  --query queryId --output text --profile learn-sandbox --region us-east-1)
aws logs get-query-results --query-id "$QID" --profile learn-sandbox --region us-east-1

# Set retention so logs do not live (and bill) forever.
aws logs put-retention-policy --log-group-name /hl/m13/rates-api --retention-in-days 30 \
  --profile learn-sandbox --region us-east-1

# A CloudWatch alarm on ALB 5xx errors, notifying an SNS topic (replace the dimension and topic ARN).
aws cloudwatch put-metric-alarm --alarm-name hl-m13-5xx --namespace AWS/ApplicationELB \
  --metric-name HTTPCode_Target_5XX_Count --dimensions Name=LoadBalancer,Value=app/hl-m13/abc123 \
  --statistic Sum --period 60 --evaluation-periods 3 --threshold 5 --comparison-operator GreaterThanThreshold \
  --treat-missing-data notBreaching --alarm-actions arn:aws:sns:us-east-1:111122223333:hl-m13-oncall \
  --profile learn-sandbox --region us-east-1

# Identity Center: which instance and identity store do I have? (management or delegated admin account)
aws sso-admin list-instances --profile learn-sandbox --region us-east-1

The date -d syntax works on GNU date (Git Bash, Linux, CloudShell); on macOS use date -v-1H +%s. The account ID in the alarm ARN is a placeholder.

Infrastructure as Code

ObservabilityStack.cs
using Amazon.CDK;
using Amazon.CDK.AWS.CloudWatch;
using Amazon.CDK.AWS.CloudWatch.Actions;
using Amazon.CDK.AWS.Logs;
using Amazon.CDK.AWS.SNS;
using Constructs;

public sealed class ObservabilityStack : Stack
{
    public ObservabilityStack(Construct scope, string id, IStackProps props) : base(scope, id, props)
    {
        // Finite retention is a cost and privacy control: logs may contain personal data.
        var logGroup = new LogGroup(this, "Api", new LogGroupProps
        {
            LogGroupName = "/hl/m13/rates-api",
            Retention = RetentionDays.ONE_MONTH,
            RemovalPolicy = RemovalPolicy.DESTROY,
        });

        // Turn JSON error logs into a metric (the KQL "count errors" habit), then alarm on it.
        var errors = new MetricFilter(this, "Errors", new MetricFilterProps
        {
            LogGroup = logGroup,
            MetricNamespace = "Harbourline/RatesApi",
            MetricName = "ErrorCount",
            FilterPattern = FilterPattern.StringValue("$.level", "=", "Error"),
            MetricValue = "1",
        });

        var topic = new Topic(this, "OnCall");

        var alarm = new Alarm(this, "ErrorAlarm", new AlarmProps
        {
            Metric = errors.Metric(new MetricOptions { Statistic = "Sum", Period = Duration.Minutes(1) }),
            Threshold = 5,
            EvaluationPeriods = 3,
            ComparisonOperator = ComparisonOperator.GREATER_THAN_THRESHOLD,
            TreatMissingData = TreatMissingData.NOT_BREACHING,
            AlarmDescription = "Rates API error burst. Runbook: wiki/runbooks/rates-api-errors",
        });
        alarm.AddAlarmAction(new SnsAction(topic));

        Amazon.CDK.Tags.Of(this).Add("Project", "cea-lab");
        Amazon.CDK.Tags.Of(this).Add("Lab", "m13-monitoring");
        Amazon.CDK.Tags.Of(this).Add("Environment", "learn");
    }
}

Complete code

OpenTelemetry in ASP.NET Core, replacing AddApplicationInsightsTelemetry. Packages: OpenTelemetry.Extensions.Hosting, OpenTelemetry.Instrumentation.AspNetCore, OpenTelemetry.Instrumentation.Http, OpenTelemetry.Exporter.OpenTelemetryProtocol (use the current stable versions).

Program.cs
using OpenTelemetry;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

var builder = WebApplication.CreateBuilder(args);

// Before: builder.Services.AddApplicationInsightsTelemetry(connectionString);
// After: OpenTelemetry, exported over OTLP to a collector (ADOT) at OTEL_EXPORTER_OTLP_ENDPOINT.
builder.Services.AddOpenTelemetry()
    .ConfigureResource(r => r.AddService("harbourline-rates-api", serviceVersion: "1.0.0"))
    .WithTracing(t => t
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation())
    .UseOtlpExporter();

builder.Logging.ClearProviders();
builder.Logging.AddJsonConsole(); // fields become queryable in Logs Insights

var app = builder.Build();
app.MapGet("/rates/{from}/{to}", (string from, string to) => Results.Ok(new { from, to, rate = 1.17m }));
app.Run();

Validating Cognito tokens in an API that used to validate Entra tokens. This is the claim difference that most often breaks a migration: Cognito access tokens carry client_id, not aud.

CognitoAuth.cs
using System.Security.Claims;
using Microsoft.AspNetCore.Authentication.JwtBearer;

public static class CognitoAuth
{
    public static IServiceCollection AddCognitoJwt(this IServiceCollection services, string region, string userPoolId, string appClientId)
    {
        services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
            .AddJwtBearer(options =>
            {
                // Metadata (and signing keys) are discovered from this issuer.
                options.Authority = $"https://cognito-idp.{region}.amazonaws.com/{userPoolId}";
                options.TokenValidationParameters.ValidateAudience = false; // access tokens have no "aud"
                options.TokenValidationParameters.ValidateIssuer = true;
                options.Events = new JwtBearerEvents
                {
                    OnTokenValidated = ctx =>
                    {
                        // Entra: validate "aud". Cognito access token: validate "client_id" and "token_use".
                        var clientId = ctx.Principal?.FindFirstValue("client_id");
                        var use = ctx.Principal?.FindFirstValue("token_use");
                        if (clientId != appClientId || use != "access")
                        {
                            ctx.Fail("Token was not issued to this application.");
                        }
                        return Task.CompletedTask;
                    },
                };
            });
        return services;
    }
}

Code explained line by line

  1. AddOpenTelemetry().ConfigureResource(...) names the service; every span carries this name, which is how the service appears on the map.
  2. AddAspNetCoreInstrumentation and AddHttpClientInstrumentation create spans for incoming requests and outgoing HTTP calls with no code in your handlers.
  3. UseOtlpExporter() sends telemetry to the OTLP endpoint named by OTEL_EXPORTER_OTLP_ENDPOINT, normally an ADOT collector sidecar that forwards to CloudWatch and X-Ray. Check how your collector handles trace ID format ⚠ VERIFY.
  4. AddJsonConsole() writes structured logs that Logs Insights can query by field.
  5. In AddCognitoJwt, Authority makes the middleware download the user pool's signing keys. ValidateAudience = false is intentional for Cognito access tokens, which omit aud.
  6. OnTokenValidated replaces the audience check with client_id and token_use. Without it, a token for any app client in the pool would be accepted.

Security considerations

⚠ Learning shortcut — not for production

The examples send telemetry without redaction and treat any Cognito access token for one client as sufficient. Production adds log redaction (no account numbers, tokens or personal data in logs or span attributes), per-environment log groups with encryption by a customer managed key and finite retention, scope checks on tokens (scope claim per API), MFA enforced in the identity provider, and CloudTrail plus alarms on root and privileged role use.

  • Observability data is personal data when it contains identifiers. Treat log retention and access as UK GDPR matters; involve your DPO.
  • Least privilege for readers. Giving everyone CloudWatchLogsFullAccess lets any developer read production customer data in logs. Use read-only permission sets per account.
  • Trust direction on Managed AD. A one-way trust lets on-premises users access AWS-hosted resources; the opposite direction exposes the AWS domain to on-premises. Choose the minimum and review with your security architects.
  • Identity source change is destructive. Test the Entra connection in a sandbox organisation before touching production assignments.
  • Revocation drill. Disable a test user in Entra, measure how long until AWS access stops (SCIM sync plus session length), and record it.

Banking use case

Harbourline's on-call rota needs four things on day one of the first production workload on AWS: a dashboard per service with the same four golden signals as before, an alarm per Azure alert rule that currently pages, KQL-to-Logs-Insights saved queries pinned in the runbooks, and staff sign-in through the existing Entra ID with Conditional Access. The SRE team converts its ten most-used KQL queries first, tests them against logs from a game day, and stores the Logs Insights equivalents in the runbook repository. For identity, staff use Pattern A with permission sets named after job functions (Payments-ReadOnly, Payments-Operator), Windows workloads use Pattern B for the SQL Server login, and customers are migrated to Cognito in a later wave once the token differences are handled.

Common mistakes

  • Keeping the Application Insights SDK. It keeps sending to Azure. Switch to OpenTelemetry so you can choose the backend.
  • Forgetting retention. CloudWatch log groups never expire by default; costs and personal data accumulate.
  • Translating KQL line by line. Logs Insights has a smaller command set; restructure the question, and move heavy analytics to Athena over exported logs.
  • Assuming Entra Conditional Access applies to API calls. It controls the sign-in; the session then works within its permissions. Add IAM conditions for sensitive actions.
  • Choosing Simple AD. It is in maintenance; choose Managed Microsoft AD or AD Connector.
  • Validating aud on Cognito access tokens. They have no aud, so every request is rejected, or the check gets removed entirely and security weakens.

Troubleshooting

SymptomLikely causeFix
Logs Insights returns no rowsWrong log group, time range, or field nameRun fields @timestamp, @message | limit 20 to see the real field names
Alarm stays INSUFFICIENT_DATAMetric has no data points; treat-missing-data settingCheck the metric exists; set notBreaching for sparse metrics
No traces appearCollector not reachable or wrong OTLP endpointCheck OTEL_EXPORTER_OTLP_ENDPOINT and collector logs; confirm port 4317 (gRPC) or 4318 (HTTP)
Identity Center login loops back to EntraSAML attribute or audience mismatchCompare the ACS URL and entity ID in both consoles
User exists in Entra but not in AWSNot in a group assigned to the SCIM app, or provisioning cycle pendingAssign the group; trigger provisioning on demand
401 from API with a valid Cognito tokenAudience validation on an access tokenDisable ValidateAudience and validate client_id
Windows auth to RDS failsNo trust or the DNS cannot resolve the domainVerify the Managed AD trust state and Route 53 Resolver rules

Cost and cleanup

Cost label: free for the CLI, queries, CDK synthesis and OpenTelemetry code. CloudWatch has a free allowance for basic metrics, alarms and log ingestion; beyond it, log ingestion is billed per GB ⚠ VERIFY the current prices. AWS Managed Microsoft AD, Identity Center SAML federation with a real Entra tenant, and Cognito at scale are design-only here: Managed AD is billed hourly, and connecting a production Entra tenant belongs in a controlled change. Free alternative: do the identity exercises as diagrams and the Logs Insights exercises against logs from your own local runs sent to a sandbox log group.

cdk destroy ObservabilityStack --profile learn-sandbox
# or delete by hand
aws logs delete-log-group --log-group-name /hl/m13/rates-api --profile learn-sandbox --region us-east-1
aws cloudwatch delete-alarms --alarm-names hl-m13-5xx hl-m13-error-burst --profile learn-sandbox --region us-east-1

# Verify nothing tagged for the course remains
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=cea-lab \
  --profile learn-sandbox --region us-east-1 --query "ResourceTagMappingList[].ResourceARN"

Exercises

  • 🟢 Guided: translate the three KQL queries above to Logs Insights against a log group that holds JSON logs from the Rates API, and confirm the field names with fields @timestamp, @message.
  • 🟡 Challenge: write a Pattern chooser as a table for five Harbourline systems (staff portal, SQL Server on EC2, RDS for SQL Server with Windows auth, mobile banking app, a third-party SaaS) naming the pattern and its failure mode.
  • 🔴 Live problem: an auditor asks "how quickly does a leaver lose access to production on AWS?" Design the measurement, name every delay in the chain (Entra disable, SCIM sync, existing sessions, role session duration), and propose a control that shortens the longest one.

Assignment

Write a monitoring and identity migration plan for one service: current alerts and queries with their AWS equivalents, an OpenTelemetry instrumentation change, the identity pattern per user population, retention settings, and a revocation test. Commit it to your portfolio repository.

Solutions

Knowledge check

Interview questions

  • "How do you keep Conditional Access when staff sign in to AWS?" Enforce MFA and device rules in Entra ID at sign-in, since the SAML assertion is only issued after they pass; AWS then limits what the session can do with permission sets and IAM conditions.
  • "What would you check first if Logs Insights shows nothing?" The log group and time range, then whether the logs are structured JSON so fields exist.
  • "When is Managed Microsoft AD needed?" When AWS-hosted Windows or SQL Server workloads need Kerberos or Windows authentication and Group Policy, typically with a trust to on-premises AD.

Certification practice

Completion checklist

  • I can map Azure Monitor, Log Analytics and Application Insights to AWS services
  • I translated three KQL queries to Logs Insights
  • I can explain the four identity patterns and a failure mode of each
  • I removed any log group or alarm I created and ran the tag query

Key takeaways

  • Use OpenTelemetry so telemetry is portable; X-Ray is a backend, not an SDK choice.
  • KQL does not run on AWS: rewrite queries for Logs Insights, PPL or SQL, and keep logs structured.
  • Entra ID stays the directory; Identity Center is the AWS front door via SAML and SCIM.
  • Managed AD is for Windows workloads; Simple AD is in maintenance.
  • Cognito tokens differ from Entra's; fix audience validation first.

Further reading

Independent learning resource — not affiliated with, endorsed or sponsored by Amazon Web Services. AWS and related marks are trademarks of Amazon.com, Inc. or its affiliates. All banking data in examples is fictional. Sample architectures are for learning and are not automatically compliant with GDPR, PCI DSS or any banking regulation.

On this page