Ugrás a fő tartalomhoz

Cloud Assessment and Migration Assessment

Basic Advanced

Service: Cloud Assessment · Migration Assessment · Typical shape: 1-3 weeks, fixed price, 1 lead architect + 1-2 engineers, read-only access to the customer estate

Two offers share one engine. A Cloud Assessment reviews an estate that already runs in the cloud (AWS, STACKIT, OCI, or a mix) for security gaps, cost waste, and structural improvements. A Migration Assessment inventories an on-premise or hosted estate, maps dependencies, and turns it into a scoped, de-risked migration plan. Both are time-boxed, evidence-driven, and end with a roadmap that feeds straight into Cloud Migration & Modernization or a platform build on STACKIT.

What we deliver​

DeliverableCloud AssessmentMigration Assessment
Executive summary (2 pages)YesYes
Well-Architected review per workload, all six pillarsYesTarget-state review only
Security posture scan report (CSPM + IaC) with severity-ranked findingsYesFor any existing cloud footprint
FinOps baseline: cost by owner/env, waste list, commitment planYesTarget-state cost model
Inventory + dependency map (servers, DBs, flows)LightYes, core output
7 Rs disposition per applicationOptionalYes
TCO model (current vs. target, 3-5 years)OptionalYes
Wave plan with move groups and cutover windowsNoYes
Roadmap: quick wins (≤ 30 days), next 90 days, 6-12 monthsYesYes
Raw evidence pack (scan outputs, queries, spreadsheets)YesYes

The raw evidence pack is non-negotiable: every finding links to the scanner output, query, or interview note that supports it, so the customer's team can reproduce it.

Reference architecture​

All tooling runs from a Lieber-controlled, ephemeral assessment runner (a container or short-lived VM) with read-only credentials. Nothing is installed in production accounts except, for migration discovery, a collector appliance the customer approves.

Week-by-week method​

Week 0 (pre-start, 2-3 days before kickoff)​

  • Signed scope: account/tenancy/project list, workload list, out-of-scope items.
  • Access request sent as code (see step 1 below), plus a named customer contact per domain: network, security, finance, application owners.
  • Interview calendar booked (6-10 sessions, 45 min each).

Week 1: discover​

DayCloud AssessmentMigration Assessment
1Kickoff, access verification, run first CSPM scansKickoff, deploy discovery collector, import RVTools/CMDB exports
2Steampipe inventory, tagging coverage, IAM reviewInterviews: app owners (business criticality, RTO/RPO, change windows)
3Billing export ingest, cost by owner/envNetwork flow collection running; licensing inventory
4Well-Architected interviews per workloadData platforms: DB engines, sizes, change rates
5Triage call: confirm preliminary criticalsData quality review of the inventory; fill gaps

Critical findings (public data exposure, root keys, internet-open admin ports) are reported the same day to the customer's security contact, not saved for the final report.

Week 2: analyse​

  • Cloud: Well-Architected answers, scan triage (deduplicate, false-positive review, severity), rightsizing and commitment analysis, architecture risks.
  • Migration: dependency graph and move groups, 7 Rs disposition, target architecture sketch, TCO model.

Week 3: recommend (or compress into days 9-10 for a 2-week run)​

  • Roadmap with effort and owner per item; wave plan for migrations.
  • Read-out to technical team first, then executive read-out.
  • Handover of evidence pack and IaC snippets for quick wins.

For a 1-week assessment, cut scope to the top 3-5 workloads, run tooling on day 1, interview days 2-3, and read out on day 5.

Implementation steps​

1. Provision read-only access as code​

AWS: a cross-account role in every member account (via StackSet or the customer's landing zone pipeline) trusting the runner account, with the AWS-managed SecurityAudit and ViewOnlyAccess policies. Prowler documents the extra permissions it needs in its own additions policy.

aws-assessment-role.tf
resource "aws_iam_role" "lieber_assessment" {
name = "LieberAssessmentReadOnly"
max_session_duration = 43200
assume_role_policy = jsonencode({
Version = "2012-10-17"
Statement = [{
Effect = "Allow"
Principal = { AWS = "arn:aws:iam::${var.runner_account_id}:root" }
Action = "sts:AssumeRole"
Condition = { StringEquals = { "sts:ExternalId" = var.external_id } }
}]
})
}

resource "aws_iam_role_policy_attachment" "audit" {
for_each = toset(["arn:aws:iam::aws:policy/SecurityAudit", "arn:aws:iam::aws:policy/job-function/ViewOnlyAccess"])
role = aws_iam_role.lieber_assessment.name
policy_arn = each.value
}

STACKIT: a service account with the reader role at organization or folder level (see Sovereign Cloud on STACKIT). OCI: a group with inspect all-resources and read all-resources at tenancy level. Set an expiry date on every credential equal to the assessment end date plus one week.

2. Security posture scans​

ToolUse it forStatus (as of 2026-10)
ProwlerCSPM baseline for AWS, Azure, GCP, Kubernetes, OCI, OpenStack, M365, GitHub; maps checks to CIS, ISO 27001, BSI C5, NIS2-adjacent frameworksActively released, 5.x line (5.45.0 on 2026-10-15)
Steampipe + PowerpipeSQL over cloud APIs for custom inventory queries; Powerpipe runs benchmark mods (AWS Compliance, AWS Well-Architected)Active; Powerpipe is the benchmark/dashboard runner, Steampipe the query engine
CheckovIaC policy scanning (Terraform/OpenTofu, CloudFormation, Kubernetes, Helm) including graph checks across resourcesActive, 3.x
Trivy configIaC misconfiguration + container image CVEs in one tool; successor to tfsecActive, 0.7x line
ScoutSuiteLegacy multi-cloud auditorNewest tag v5.14.0; activity not verified; use Prowler instead
tfsec, TerrascanLegacy IaC scannerstfsec merged into Trivy; Terrascan archived (Nov 2025)

Run from the assessment runner with pinned versions:

scan.sh
set -euo pipefail
OUT=evidence/$(date +%F)
mkdir -p "$OUT"

# Prowler: all regions, compliance mappings, machine-readable outputs
pip install "prowler==5.45.0"
prowler aws \
--role "arn:aws:iam::${ACCOUNT}:role/LieberAssessmentReadOnly" --external-id "$EXTERNAL_ID" \
--compliance cis_4.0_aws iso27001_2022_aws \
--output-formats csv json-ocsf html -o "$OUT/prowler"

# Powerpipe: Well-Architected and CIS benchmarks backed by Steampipe
steampipe service start
powerpipe mod install github.com/turbot/steampipe-mod-aws-well-architected
powerpipe benchmark list # note the Well-Architected and CIS v4.0 benchmark names
powerpipe benchmark run <wa-benchmark> --export "$OUT/wa.json"
powerpipe benchmark run <cis-v4-benchmark> --export "$OUT/cis.json"

# IaC
checkov -d ./iac --framework terraform kubernetes -o json > "$OUT/checkov.json"
trivy config --scanners misconfig --format json -o "$OUT/trivy-config.json" ./iac

Confirm the Prowler compliance IDs against the --compliance choices in prowler aws --help for the pinned version before running; IDs change between releases.

Steampipe is also the fastest way to answer one-off questions during interviews:

untagged-and-public.sql
-- EC2 instances missing the mandatory cost-allocation tags
select account_id, region, instance_id, instance_type
from aws_ec2_instance
where tags ->> 'cost-center' is null or tags ->> 'env' is null;

-- Security groups exposing SSH/RDP to the internet
select group_id, group_name, account_id, region
from aws_vpc_security_group_rule
where not is_egress and cidr_ipv4 = '0.0.0.0/0'
and (from_port <= 22 and to_port >= 22 or from_port <= 3389 and to_port >= 3389);

3. Well-Architected review​

Use the AWS Well-Architected Tool for AWS workloads: define one workload per business service, answer questions in interviews (not alone), and export the improvement plan. The Framework lens is applied by default; add catalog lenses that match the workload — the Lens Catalog includes Generative AI, Machine Learning, Serverless Applications, SaaS, Container Build, DevOps, Data Analytics, Financial Services, Healthcare, Government, and the Migration Lens for migration assessments. Up to five lenses can be added at a time per workload.

The six pillars — operational excellence, security, reliability, performance efficiency, cost optimization, sustainability — are provider-neutral. For STACKIT and OCI workloads we run the same question set from our own spreadsheet template, with provider-specific evidence:

PillarAWS evidenceSTACKIT evidenceOCI evidence
SecuritySecurity Hub, IAM Access Analyzer, ProwlerOrg/project role assignments, service account keys, KMS usage, Secrets Manager ACLsCloud Guard, IAM policies, Prowler OCI
ReliabilityMulti-AZ placement, AWS Backup plansAZ spread (eu01-1..3, Metro eu01-m), server backup schedules, PostgreSQL Flex replica flavorsFault domains, block volume backups
CostCUR 2.0 / FOCUS export, Compute OptimizerUsage export per project, billingReference labelsFOCUS cost reports, budgets
OperationsCloudWatch, Config, IaC coverageObservability instance, IaC coverageMonitoring, Logging, IaC coverage

IaC coverage (share of resources managed by OpenTofu/Terraform state) is our single most predictive operational metric. Compute it by diffing a Steampipe inventory against tofu state list across all state files.

4. FinOps baseline​

  1. Get normalised billing data. Prefer FOCUS exports: FOCUS 1.4 is the latest published version (as of 2026-10; the spec page gives no ratification date); AWS Data Exports offers "FOCUS 1.2 with AWS columns" (announcement), and Oracle Cloud is among the providers with native FOCUS exports. One schema lets one notebook cover AWS, OCI, and SaaS lines.
  2. Allocate. Measure tag coverage by cost, not by resource count. AWS user-defined tags must be activated as cost allocation tags and take up to 24 h to appear plus up to 24 h to activate — do this on day 1. On STACKIT, use project structure plus the billingReference label.
  3. Find waste. Idle and unattached resources, oversized instances (p95 CPU and memory over 14-30 days), old snapshots, non-prod running 24/7, data transfer hotspots.
  4. Plan commitments. Only after rightsizing. Cover the stable baseline (the minimum hourly spend over the last 30-60 days) with Savings Plans/reserved capacity; leave the variable part on demand.
focus-baseline.sql (DuckDB)
-- Cost by service and allocation tag over the last full month
select ServiceName,
coalesce(Tags['cost-center'], 'UNALLOCATED') as cost_center,
round(sum(EffectiveCost), 2) as effective_cost
from read_parquet('focus/*.parquet')
where BillingPeriodStart = date '2026-09-01'
group by all
order by effective_cost desc;

Column names (EffectiveCost, ServiceName, Tags, BillingPeriodStart) are FOCUS-standard, so the same query runs against any conformant export. Report savings as monthly EUR ranges with confidence (high/medium/low), never as a single headline number.

5. Discovery and dependency mapping (Migration Assessment)​

Current AWS tooling (as of 2026-10): AWS Migration Hub and AWS Application Discovery Service stopped accepting new customers on 2025-11-07; AWS Transform is the successor for assessment, planning, and VMware migration. Its discovery tool is an agentless appliance for vCenter and Hyper-V (plus CSV imports) that collects utilisation over time, SQL Server/Oracle metadata, and server-to-server connections, and can run without cloud connectivity. Note that Transform assessments do not map application dependencies — we build move groups from its connection data ourselves.

Provider-neutral path (STACKIT, OCI, or OpenStack targets, and every sovereign engagement):

DataSourceTool
VM inventoryvCenterRVTools export (vInfo, vCPU, vMemory, vDisk, vNetwork sheets)
UtilisationHypervisor + guestvCenter performance API, or node_exporter for 2-4 weeks
Network flowsGuestsss -tnp sampling script, NetFlow/IPFIX from core switches, firewall logs
DatabasesDB catalogsEngine, version, size, change rate (WAL/redo per hour), linked servers
Ownership, criticalityCMDB + interviewsSpreadsheet, validated per app owner
collect-flows.sh (run every 5 min for ≥ 14 days, via cron or Ansible)
ts=$(date -u +%FT%TZ)
ss -Htnp state established | awk -v h="$(hostname -f)" -v t="$ts" \
'{split($4,l,":"); split($5,r,":"); print t","h","l[1]","l[2]","r[1]","r[2]","$6}' \
>> /var/tmp/lieber-flows.csv

Load flows into a graph (NetworkX or Neo4j), collapse by listening port to services, then compute connected components: each strongly connected cluster with chatty, low-latency traffic is a move group that migrates together. Flows that cross move groups become explicit interface items in the plan (latency budget, firewall rule, DNS change).

6. 7 Rs disposition​

Use the AWS 7 Rs vocabulary on every target cloud — it is the industry lingua franca:

RMeaningChoose whenTypical tooling
RetireDecommissionNo active users, duplicated functionUsage logs, owner sign-off
RetainKeep where it is (for now)Hardware/licence lock, low value to move, sovereignty constraintRevisit date
RehostLift-and-shift VM as isSpeed matters, app is stableAWS MGN, image import, OpenStack virt-v2v
RelocateMove hypervisor-level, no VM changeVMware to a VMware-compatible cloudVendor tooling
RepurchaseReplace with SaaSCommodity function (email, CRM, ITSM)Vendor migration
ReplatformSmall changes for managed servicesDB to managed PostgreSQL, app to containersDMS, logical replication, containers
RefactorRe-architectBusiness needs scale/agility the current design blocksStrangler fig, Kubernetes

Our rule, aligned with AWS guidance for large migrations: rehost or replatform first, refactor after the move, unless the app cannot run in the target as is. Record the disposition and its one-line reason per app.

7. TCO model​

Build the model in a spreadsheet with one row per cost line and explicit assumptions on a separate tab. Minimum structure:

BlockCurrent stateTarget state
Compute/storage/networkHardware depreciation, DC space, power, hypervisor licencesRightsized instances from utilisation (p95), storage tiers, egress
LicencesOS, DB, VMware, backupBYOL vs. included, managed DB pricing
PeopleFTE for hardware, patching, DC opsFTE for cloud ops, platform team
Migration one-off—Engineering effort, dual running (2-3 months per wave), training
Risk/complianceAudit effort, DR siteProvider attestations reuse (C5, ISO 27001)

Show 3- and 5-year cumulative cost, the break-even month, and a sensitivity table for the three biggest assumptions (usually instance sizing, egress, and FTE). Size from measured utilisation, never from allocated vCPU/RAM.

8. Migration wave planning​

  • Wave 0 (pilot): 1-3 low-risk apps that exercise the full toolchain (landing zone, network, replication, cutover, monitoring). The customer chooses one they care about so trust is real.
  • Waves 1..n: move groups ordered by dependency (shared services first: DNS, identity, monitoring), then increasing criticality. Cap each wave by cutover window, team capacity, and replication bandwidth.

Bandwidth check per wave: initial_sync_hours = total_GB × 8 / (link_Mbps × 0.7 utilisation) / 3600 × 1000. Example: 20 TB over 1 Gbps at 70% ≈ 63 h of initial sync, before change-rate catch-up.

wave-plan.csv (excerpt)
wave,move_group,app,disposition,servers,data_gb,rto_h,cutover_window,owner,blockers
0,MG-01,intranet-wiki,rehost,2,120,24,Sat 22:00-02:00,J. Kovacs,none
1,MG-04,billing-api,replatform,5,900,4,Sat 20:00-04:00,A. Nagy,DB to PostgreSQL Flex

9. Findings and report template​

Every finding uses the same structure, scored by severity × effort:

finding-template.md
### F-012 Internet-exposed RDP on 3 production instances
- Severity: High (Critical / High / Medium / Low / Info)
- Pillar: Security · Framework mapping: CIS AWS 4.0 5.3
- Evidence: evidence/2026-10-06/prowler/...json#L120, screenshot SG sg-0abc
- Impact: brute-force and ransomware entry point on billing hosts
- Recommendation: remove 0.0.0.0/0 rules; use SSM Session Manager / bastion
- Effort: S (≤ 1 day) · Owner: Platform team · Roadmap: Quick win
SeverityDefinition
CriticalActive exposure of data or admin plane; fix within days, reported same day
HighExploitable weakness or major cost/reliability risk; fix within 30 days
MediumDefence-in-depth or efficiency gap; fix within 90 days
Low / InfoHygiene, documentation, future-proofing

The roadmap groups findings into quick wins (high value, effort S), next 90 days, and 6-12 months (structural: landing zone, IaC adoption, platform migration), each with an owner and a rough effort in person-days.

Best practices​

  • Interview with the Well-Architected questions open; scanners find configuration, interviews find process gaps.
  • Pin tool versions and record them in the report, so a re-run in six months is comparable.
  • Triage scanner output before it reaches the customer: deduplicate per root cause (one SCP fixes 200 findings).
  • Quantify cost findings in EUR per month with the query that produced them.
  • For sovereign targets, add residency and operator-access questions to every workload review (see the sovereignty checklist).
  • Keep flow collection running for at least two weeks, including a month-end if batch jobs exist.

Pitfalls to design around​

  • Access lead time: send the access-as-code request in week 0 so day 1 starts with scans.
  • Allocated vs. used capacity: size TCO from p95 utilisation; allocated vCPU overstates target cost.
  • Hidden dependencies: batch jobs, file shares, and hard-coded IPs show up only in long flow captures and interviews; ask explicitly about month-end and year-end processes.
  • Licensing: capture licence terms (Oracle, SQL Server, Windows, VMware) as first-class TCO inputs; they often decide the disposition.
  • Scope creep: park new asks in a "follow-on" list in the report rather than extending the time box.

Definition of done​

  • Read-only access provisioned as code, with expiry, and revoked at close
  • Prowler/Powerpipe/Checkov/Trivy runs stored with pinned versions in the evidence pack
  • Well-Architected review completed for every in-scope workload (WA Tool export or template)
  • All Critical findings reported same day and acknowledged by the customer
  • Every finding has severity, evidence link, recommendation, effort, owner
  • FinOps baseline: allocation coverage %, waste list in EUR/month, commitment recommendation
  • (Migration) Inventory validated by app owners; dependency graph and move groups delivered
  • (Migration) 7 Rs disposition with reason per app; TCO with sensitivity; wave plan with Wave 0 pilot
  • Roadmap: quick wins, 90 days, 6-12 months, each with owner and effort
  • Technical and executive read-outs held; follow-on scope captured

Sources​