StackToIT Migration Intelligence Workspace

Costs

Priced and unpriced coverage, and the inputs a cost estimate needs. The figures are an initial infrastructure cost estimate under explicit assumptions (the assumptions below), under one labelled scenario (the labelled standard month of 730 hours, the same on both sides); they are not a bill.

Four classes of line

Every line below is one of four classes, so that a known figure is not read as an estimate or an assumption, and a line that is not computed is not read as zero.

22 cost lines in all: 14 of the source, 8 of the target. The same lines and totals are in financial/cost-model.json, financial/priced-resources.csv and financial/cost-coverage.md.

Coverage: how much of the estate the model can price

Billable coverage: which source resources can carry a price. Most source resources carry no charge of their own (a security group rule, an IAM role, a route), so the share of source resources that have a line is not the share of the estate that is priced. Of the 33 source resources, 20 are or may be billed. The source resources of the cost model are the managed resources of the source that no count or for_each of 0 switches off; the resources scanned of the first screen also count the switched-off ones, so its figure can be larger.

Out of the model, by type: google_cloudbuild_trigger (3), google_secret_manager_secret_iam_binding (2), google_storage_bucket_iam_member (2), google_cloud_run_service_iam_policy (1), google_firebase_hosting_site (1), google_firebase_project (1), google_project_service (1), google_sql_database (1), google_sql_user (1).

Price coverage: which lines have a price. Of the 22 lines of the model, both sides.

Lines with a price found, by side: source 0 of 14, target 2 of 8. Of the lines without a price, by diagnostic: CACHE_MISSING (5), TARGET_NOT_CHOSEN (4), AMBIGUOUS (1), USAGE_NOT_STATED (1) (a refresh of the price cache fixes only CACHE_MISSING).

Usage coverage: which priced lines have a quantity. Of the 2 lines that have a price.

A subtotal is the sum of the list prices of the lines that are priced, for the resources this build prices. It is not the cost of running the estate: usage and traffic that no assumption states, support, licences, operation and the effort of the migration are not in it. A difference between the source and the target subtotal is the difference of those list prices over the same resources, in one currency; it is not the saving, or the cost, of the migration.

Estimated monthly cost for the resources that could be compared (730 h, list prices)

A saving or an increase is stated only over the source resources that both sides price in full (0 resources); the other resources are listed under cost groups with why they are not computed, and are in no figure here.

Not in this sum: 20 source resources (0 with a price known and the quantity unknown, 20 not computed): google_cloudbuild_trigger (3), google_secret_manager_secret (2), google_secret_manager_secret_iam_binding (2), google_storage_bucket_iam_member (2), google_cloud_run_service_iam_policy (1), google_cloud_run_v2_job (1), 9 more kinds. They are not zero and not free. 13 more resources carry no charge of their own and are nothing to compute.

No line is summed: the computed subtotal is empty. A line of the class OUT_OF_MODEL is not computed, is in no sum and is never filled in as zero.

No source unit is priced on both sides: there is no computed subtotal.

This is the computed subset of 0 of 33 source resources, not the estate's whole cost. The resources outside it (price known with the quantity unknown, or out of the model) are in no total, saving or percentage of this comparison. A difference between the source and the target subtotal is the difference of those list prices over the same resources, in one currency; it is not the saving, or the cost, of the migration.

Source against target over the computed units: NOT COMPARED; saving of the target not given (no source unit is priced on both sides, so there is no computed subtotal to compare).

Outside this comparison: STACKIT, target only, no source line stands against them: 1 line, 72.70 EUR; STACKIT, priced lines of units that are not compared: 1 line, 91.97 EUR. The target-only lines are in the priced part of the STACKIT total, and no saving includes them.

A difference stated here is a difference over the compared part only, not a saving of the estate. What the compared part leaves out: priced but outside the comparison (STACKIT, target only, no source line stands against them: 1 line, 72.70 EUR; STACKIT, priced lines of units that are not compared: 1 line, 91.97 EUR); without a price: 14 source lines (9 PRICE_NOT_FOUND, 5 PRICE_SOURCE_ABSENT), 6 STACKIT lines (1 AMBIGUOUS, 1 QUANTITY_UNKNOWN, 4 TARGET_NOT_CHOSEN); reasons: 5 no cache · 4 target not chosen · 1 ambiguous · 1 use not stated; 20 of 20 billable source resources not compared; usage and traffic that no assumption states, support, licences, operations and the one-off costs of the migration are in no figure (the cost of both estates running side by side during the cutover is stated apart, as a one-off item).

Technical mapping

Beside the prices, what each side of a computed pair states about its size and performance. A fact a side does not state is shown as not stated, never filled in. A pair whose cost is only partly known (a component with no price) is listed too, with how many of its components are priced under its name; it is in no computed subtotal. The same table is financial/mapping.csv.

A machine type is one of the types of the catalogue with at least the vCPUs and memory of the source (a burstable source may be offered shared types); a storage class is the one the draft names (the customer's answer or the variable's default), shown with the catalogue's own IOPS and throughput. This table states sizes; it is not a statement about the performance of the target against the source (no benchmark was run, and a CPU model that a side does not state is shown as not stated).

Assumptions

• Scenario: STANDARD_730H, 730 hours per period (the labelled standard month of 730 hours, the same on both sides).
• Assumption file: none was given, so every quantity is the source's own or unknown.
• Prices: net list prices of the price sources below, no discount and no contract price; no usage, traffic, egress or support cost is computed unless the assumption file states the use of one month (a line priced on it is an assumption), and no one-off cost of the migration is in a total; what it costs to run both estates during the cutover is stated apart (while both estates run); what these figures are not.

Totals

The state of an estate row is the estate's: PARTIAL while any line of any source resource the model knows is not priced, a resource outside the modelled part included; the computed subtotal of the equal-scope comparison has a state of its own. Its amount is the modelled infrastructure subtotal (3 of 33 source resources): the sum of the lines that are priced; N is the number of source resources with a priced line and M all the source resources the model knows (a source resource is a Terraform resource; one migration unit can stand for several). A resource with no priced line (a load balancer, a bucket, a quantity the source does not state) is not in it, and the lines of a counted resource that are not priced are counted beside the amount and never filled in; so it is not the cost of the estate.

FULL: every line of the scope is priced. PARTIAL: the priced lines are summed and the others are counted, never filled in. NONE: no line of the scope has an amount. An unknown quantity is neither zero nor one, and a line without a price is never free.

Cost groups

Every source unit is in one of three groups. Computed: every line of it, on both sides, has an amount; only these lines make the computed subtotals, so the source and the target subtotal cover the same units and may be compared. Quantity unknown: the price of each open line is known and its quantity is not; the quantity that is needed is named. Not computed: a unit of a type out of the model (no quantity driver; the coverage table counts those apart, by type), a unit the partial draft refuses for a missing input (the coverage table counts those apart as refused), a unit with no line on one side, or a line without a price record; listed by resource with the reason, never zero and never free. It holds every unit counted as out of the model or as refused and the units priced on one side only, so its count is the larger.

Computed (0 items)

Price known, quantity unknown (0)

None.

Not computed (18)

Not computed, and not zero: each resource with why.

No charge of its own (13)

Nothing to price, and not out of the model: the source cloud bills nothing for a resource of these types of its own.

Source against target, by scope

A difference between the source and the target subtotal is the difference of those list prices over the same resources, in one currency; it is not the saving, or the cost, of the migration.

A difference stated here is a difference over the compared part only, not a saving of the estate. What the compared part leaves out: priced but outside the comparison (STACKIT, target only, no source line stands against them: 1 line, 72.70 EUR; STACKIT, priced lines of units that are not compared: 1 line, 91.97 EUR); without a price: 14 source lines (9 PRICE_NOT_FOUND, 5 PRICE_SOURCE_ABSENT), 6 STACKIT lines (1 AMBIGUOUS, 1 QUANTITY_UNKNOWN, 4 TARGET_NOT_CHOSEN); reasons: 5 no cache · 4 target not chosen · 1 ambiguous · 1 use not stated; 20 of 20 billable source resources not compared; usage and traffic that no assumption states, support, licences, operations and the one-off costs of the migration are in no figure (the cost of both estates running side by side during the cutover is stated apart, as a one-off item).

While both estates run

While both estates run (the cutover), per month of overlap: source no figure (no line of its estate is priced) and STACKIT 164.67 EUR, each in its own currency; no length of overlap is assumed (parallel_run_months in the assumption file states one); priced part only, so a lower bound (STACKIT: 2 of 8 lines priced). A one-off cost of the migration: in no total, comparison or saving.

Both estates run while the migration is cut over. These are the monthly list-price subtotals of the priced lines of each side, each in the currency of its own side (no exchange rate is applied), so they are a lower bound: a line without a price is not in them. The cost of both estates running is a one-off cost of the migration: it is in no total, no comparison and no saving, and it is not the difference between the two estates.

Lines

Price sources

What these figures are not

• Only EC2 instances (aws_instance), EBS volumes (aws_ebs_volume and the root and block devices of an instance), RDS for PostgreSQL instances (aws_db_instance: instance hours, allocated storage, provisioned iops, gp3 throughput), Amazon Aurora (aws_rds_cluster_instance: the instance hours; aws_rds_cluster: the consumed storage and the I/O requests with their price and no quantity) the network families (aws_nat_gateway, aws_lb, aws_eip and the public address an instance asks for, aws_route53_zone, aws_internet_gateway: see the line on the network families below) and the managed-service families (aws_ecs_service on Fargate, aws_mq_broker, aws_elasticache_replication_group and aws_elasticache_cluster, aws_opensearch_domain, aws_dynamodb_table: see the line on them below), the control plane of an Amazon EKS cluster (aws_eks_cluster), the nodes of its managed node groups (aws_eks_node_group) and the storage of S3 buckets and EFS file systems (aws_s3_bucket, aws_efs_file_system: see the line on them below) have lines on the source side, and only STACKIT servers (each with its boot volume), volumes, PostgreSQL Flex instances (flavor, storage class, storage capacity), public IPs, load balancers, DNS zones, RabbitMQ, Valkey, OpenSearch and MariaDB instances (their plan), MongoDB Flex instances (their flavor), SKE clusters (the cluster hour and each node pool), KMS keys, Secrets Manager and Logs instances on the target side; the other drafted resources have a line that says they have no quantity rule, and every other source resource has no line and is listed in the out-of-model group.
• The network families have a line on each side, never a total over a partial set. NAT gateway: the hour of a zonal public NAT gateway is priced and the data it processes has the per-GB price and no quantity; the STACKIT price list holds no SKU for a NAT gateway or for outbound address translation, so its target line is PRICE_NOT_FOUND (a service the list does not price is not free). Load balancer: the hour of an Application or Network Load Balancer is priced and its capacity units have the price and no quantity; the target line is the hour of the plan (plan_id; a Network Load Balancer that states none is read as the default p10 the provider documents). Public IPv4 address: the hour of an Elastic IP, and of the address an instance asks for with associate_public_ip_address = true (not an address its subnet or launch template decides), against the hour of a stackit_public_ip. DNS: the month of a hosted zone (the first tier of the Route 53 price; the tier is the account's) and its queries (no quantity); the STACKIT list prices a zone by the number of records it may hold, which the draft does not state, so its target line is AMBIGUOUS. Data transfer out: the per-GB price of the first tier (every tier is named on the line) on the line of the internet gateway and no quantity; the STACKIT list holds no SKU for it, so its target line is PRICE_NOT_FOUND. A quantity that is a measurement of use (GB, capacity unit hours, queries) is never in a Terraform source and is never made up: such a line has its price and no amount. The prices are the On-Demand rows of the AmazonEC2 (NAT gateway, load balancers), AmazonVPC (public IPv4), AWSDataTransfer and AmazonRoute53 offers of the price cache, which `stacktoit prices refresh --provider aws --region R` fetches (`--offer` names one); a line whose offer the cache does not hold names the offer and the command.
• The managed-service families are priced from the On-Demand rows of the AmazonECS (Fargate vCPU and GB hours: the cpu and memory of the task definition times the desired count, which is never taken as zero when it is not stated), AmazonMQ (broker hour by engine, instance type and deployment mode; its storage has the price and no quantity), AmazonElastiCache (node hour by engine and node type times the nodes of a replication group), AmazonES (data and dedicated master node hours, EBS GB-month) and AmazonDynamoDB (provisioned read and write capacity unit hours when the table states them, at the rate beyond the free first tier, which is the whole account's; request units and storage have the price and no quantity) offers, which `stacktoit prices refresh --provider aws --region R` fetches (`--offer` names one); Fargate Spot, ECS on EC2 capacity, Windows tasks, global datastores and non-standard table classes are out of the model. The control plane of an Amazon EKS cluster is the cluster hour of the AmazonEKS offer (the standard-support hour: a cluster of a Kubernetes version past standard support is billed the extended-support hour in addition, which is not in the line, and the line says so; a local cluster on AWS Outposts and a Provisioned Control Plane tier are out of the model; the management fee of EKS Auto Mode is said, not computed). A managed node group costs nothing of its own (Amazon EKS User Guide, Managed node groups): its line is the EC2 hour of the first of its instance_types, or of its launch template, or the t3.medium Amazon EKS uses when none is stated, times its desired_size, with the operating system, tenancy and purchasing option rules of an instance (a Spot or Windows node group is not priced as On-Demand Linux) and the EBS volumes its launch template maps as lines of their own; the root volume of the nodes is not in it. The storage of an S3 bucket (S3 Standard, tiered by the size stored in a month) and of an EFS file system (Standard, or One Zone when availability_zone_name is stated) has its price and no quantity, because the data held is a measurement of use that no Terraform source states: the line names the entry of the assumption file that would price it (variable volume_size, unit GB), and the other storage classes, the requests, the transfer and the throughput are not in it. On the target side a RabbitMQ, Valkey (Key Value Store), OpenSearch or MariaDB instance is the hour of the SKU of its plan_name (the SKU is named by the plan, INFERRED from the names of the list, and its nodes and disk are checked against the list's attributes); a plan the draft leaves to a person is TARGET_NOT_CHOSEN. An SKE cluster is the cluster hour, and each node pool it states is a line of its own: the server flavor hours of its machine_type (the join of a server) times its nodes, the range between its minimum and its maximum when they differ, an unknown quantity with the price when the draft states either as a variable, and TARGET_NOT_CHOSEN when the machine type is a variable; the boot volume of each node is not in the line, and the machines of a pool are never set against the source lines of the nodes of an EKS node group (a unit of its own) or of an ECS cluster's capacity, so a pool is a target-only line (see below); the cluster hour of an SKE cluster stands against the control plane hour of an EKS cluster, but a unit whose item holds a target-only pool is not computed, so no saving is stated over it. A MongoDB Flex instance is the hour of the SKU MongoDB-Flex-<cpu>.<ram>-<Single|Replica|Sharded> of its flavor.cpu, flavor.ram and options.type (INFERRED from the names of the list, and checked against the SKU's own attributes; the rate of a Replica SKU is read as that of the whole instance with its nodes); a flavor a person sets is TARGET_NOT_CHOSEN, a flavor the list has no SKU of is PRICE_NOT_FOUND, its storage and backups are not computed, and because this build prices no DocumentDB cluster on the source side its line is target only (see below). A software KMS key version and a GB of log ingestion have their list price and no quantity; Secrets Manager is AMBIGUOUS between its tiers (the number of secret versions). A priced target line of a family whose source side has no line for the unit (an SKE cluster and its node pools, a MariaDB instance, a MongoDB Flex instance, a RabbitMQ plan against a source with no priced broker) is target only: it is counted in the STACKIT total, listed apart with its amount (target_only on the line and target_only_lines, target_only_min and target_only_max on the total), and kept out of every comparison and every saving, because no source amount stands against it; each comparison states the lines and the amount it leaves out, on both sides.
• The instance hours and the allocated storage of an RDS for PostgreSQL instance are priced from the AmazonRDS offer of the price cache (On-Demand list prices, Single-AZ or Multi-AZ as the source states; `stacktoit prices refresh --provider aws` fetches it with the AmazonEC2 offer); its provisioned IOPS (io1, io2, gp3) and the provisioned throughput of gp3 storage come from the same offer, gp3 only above the performance its allocated storage includes (a baseline of 12,000 IOPS and 500 MiB/s from 400 GiB, nothing more can be provisioned below it: Amazon RDS User Guide, DB instance storage); without that offer the lines are PRICE_SOURCE_ABSENT and the instance is never in the computed subtotal. An Aurora instance (engine aurora-mysql or aurora-postgresql) is the instance hour of its engine, its instance class and the storage configuration of its cluster, from the same offer (rules version 3 of its narrowing): Aurora Standard when the cluster states no storage_type (the provider's documented default), Aurora I/O-Optimized for storage_type = "aurora-iopt1", and both prices open (AMBIGUOUS) when the source does not state it as a fact or the instance's cluster is not a resource of the source; the cluster's consumed storage (a GB-month) and, on Standard, its I/O requests are measurements of use and have their price and no quantity. An Aurora Serverless v2 instance (db.serverless), an instance of a Multi-AZ DB cluster, backup storage beyond the free allocation, Global Database and the Data API are not computed. An offer narrowed before the Aurora rows were kept answers PRICE_SOURCE_ABSENT with the refresh command on each Aurora line. A PostgreSQL Flex Replica flavor is priced once per instance: the list gives its SKU 3 nodes and a higher rate than the Single SKU (1.6 to 2.0 times it, never 3 times), and the rate is read as that of the whole instance (evidence class INFERRED from the price list; each such line says so); how much of its storage is billed (once or per node) the list does not say, so its storage lines have the SKU and no quantity.
• The PostgreSQL Flex storage class premium-perf<n>-stackit is priced as the SKU "Block Storage for PostgreSQL Premium-Performance <n>" per disk and its capacity as "Block Storage for PostgreSQL Premium-Capacity" per GB (evidence class INFERRED from the names of the price list; each such line says so). For a replica flavor the list gives the storage per node and does not say whether the booked size is billed once or for each node, so its disks and gigabytes are the range between the two readings. The IOPS and throughput shown for the class in the technical mapping are the attributes maxIOPerSec and maxTroughInMB of that performance SKU in the price list (the catalogue states none for a PostgreSQL Flex class); whether the class covers what the source provisions is a comparison of those figures, not a statement that the two perform alike.
• The lines fall into three groups: the computed subtotal (only the source units every line of which is priced on both sides, so both subtotals cover the same units), the lines whose price is known and whose quantity is not (the quantity that is needed is named), and what is not computed (a unit of a type out of the model, a unit with no line on one side, or a line without a price), listed by resource and never zero.
• Source prices are the On-Demand list prices of the AWS offer file in the price cache (USD, net, region of the resource); Spot, Reserved, Savings Plans, Dedicated Host, capacity reservation and private prices are never used. The operating system and licence come from the assumption file: the source does not state them.
• The offer file bills an EBS volume per GB-month; this build reads it as GiB-month, the unit a volume is sized in: the Amazon EBS pricing page states "on this page, GB = 1024^3 bytes" (OFFICIAL_DOCUMENTED for that page; applying it to the offer file's unit is INFERRED). The IOPS and throughput of a gp3 volume are priced only above the baseline included in the price of its storage (3,000 IOPS, 125 MiB/s: Amazon EBS User Guide, OFFICIAL_DOCUMENTED), per volume; io2 IOPS are priced in tiers whose edges the offer file carries in descriptions only, and are not priced.
• Target prices are the net EUR list prices of the public STACKIT price list in the price cache (region eu01). A machine type or performance class the draft leaves to a person is TARGET_NOT_CHOSEN; the metro variant of a SKU is never substituted.
• The target capacity price of a volume is the capacity SKU of its performance class's tier (evidence class INFERRED from the structure of the price list).
• One month is the 730 hours of the scenario; a per-month rate is applied as the file gives it. Snapshots, backups, support plans and every other cost of usage, traffic or requests that this build has no line for are not computed.
• A saving is compared only for the same source units on both sides and in one currency (an exchange rate from the assumption file, with its source and date, converts one side).
• Google Cloud source lines are priced from the On-Demand list prices of the Cloud Billing Catalog API in the price cache (USD, net, the region of the resource; `stacktoit prices refresh --provider gcp --region R`, with your own API key in STACKTOIT_GCP_BILLING_API_KEY, fetches them; `--offer` names one catalog). The catalog has no machine-type or disk-type field: each line joins its SKU by the words of the SKU's description and needs exactly one SKU to fit (a join INFERRED from the descriptions, said on each line); no fit is PRICE_NOT_FOUND and more than one is AMBIGUOUS, never a pick.
• What the Google Cloud model prices: google_compute_instance and google_compute_instance_from_template (a predefined or custom machine type as its vCPU hours and its memory hours, a shared-core type as its instance hour; the GPUs, the Local SSD, the boot disk with its Hyperdisk or extreme-disk IOPS and throughput; the external address an access_config asks for), google_compute_instance_group_manager and google_compute_region_instance_group_manager (the instances of the one instance template the group names, between the bounds of the autoscaler that targets it, else target_size), google_compute_disk and google_compute_region_disk, google_compute_address (external), google_sql_database_instance (PostgreSQL, MySQL and SQL Server: vCPUs, memory, storage and, for SQL Server, the edition licence; Enterprise Plus, shared-core and legacy named tiers), google_container_cluster and google_container_node_pool, google_redis_instance, google_storage_bucket (also dual-region), google_compute_router_nat, google_dns_managed_zone, google_pubsub_topic, and the serverless, data, security, network and data-processing services: Cloud Run services and jobs, Cloud Functions, BigQuery, Spanner, Bigtable, Firestore, Filestore, Secret Manager, Cloud KMS, Cloud Logging, Cloud Tasks, Cloud Scheduler, Artifact Registry, Dataproc, Dataflow, Composer, load balancer forwarding rules, Cloud Armor, VPN tunnels and Interconnect (the coverage file of this run lists each line). Every other Google Cloud resource has no line and is listed in the out-of-model group.
• A machine series whose memory per vCPU this build does not read from the documentation, a Cloud SQL tier of another series, a Spanner or Firestore multi-region, a custom dual-region bucket and a Composer 1 environment are out of the model or KEY_NOT_READ with the reason on the line; a forwarding rule is priced as an additional rule, without the minimum charge that covers the first rules of a project. Spot, preemptible, sole-tenant, flex-start and reservation-bound capacity is never priced as On-Demand. A premium operating system image (Windows Server, SQL Server, Red Hat or SUSE Enterprise Linux, Ubuntu Pro) gets a licence line that names the licence and is PRICE_NOT_FOUND, so the instance is never in a computed subtotal without its licence fee; an image the source does not state is read as one with no licence fee and the line says so (an ASSUMPTION).
• No discount is applied: the sustained-use discount of the N1, N2, N2D and C2 families, committed-use discounts, the free tier of the billing account (one zonal or Autopilot GKE cluster, the first gigabytes of Pub/Sub) and negotiated prices are not in a list price. A quantity that is a measurement of use (the data a bucket holds, the data a NAT gateway or a topic moves, the VMs a NAT gateway serves, the requests and the instance time of a Cloud Run service or function, the bytes a BigQuery query scans, the operations of a key, a secret or a database, the log volume, the worker hours of a Dataflow job) is never in a Terraform source: such a line has its price and no quantity, until the assumption file states the use. A node count of a regional GKE cluster that lists no node_locations is not known (the zones GKE chooses are not in the source), so its nodes are not priced.