Hi all, can someone help with weird behavior? I'm using Terraform + Terragrunt to deploy ECS Services using Fargate. I have Terraform modules hosted in private repos, my folder structure is as follows:

├── _global
│   └── ecs_admin_ui.hcl
├── common.hcl
├── eu-west-1
│   ├── dev
│   │   ├── ecs_admin_ui
│   │   │   └── terragrunt.hcl
│   │   └── env.hcl
│   ├── prd
│   │   ├── ecs_admin_ui
│   │   │   └── terragrunt.hcl
│   │   └── env.hcl
│   ├── region.hcl
│   └── stg
│       ├── ecs_admin_ui
│       │   └── terragrunt.hcl
│       └── env.hcl
├── terragrunt.hcl
└── us-east-1
    ├── dev
    │   ├── ecs_admin_ui
    │   │   └── terragrunt.hcl
    │   └── env.hcl
    ├── prd
    │   ├── ecs_admin_ui
    │   │   └── terragrunt.hcl
    │   └── env.hcl
    ├── region.hcl
    └── stg
        ├── ecs_admin_ui
        │   └── terragrunt.hcl
        └── env.hcl

If I change something on Fargete scope, such as increase the number of containers, nothing happens on the Infracost report, However, if I create another Service on Fargate, it identifies and shows the cost on reports. My

infracost.yaml

file using GitHub Actions to deploy:

name: Infracost
on: [pull_request]

env:
  SSH_AUTH_SOCK: /tmp/ssh_agent.sock
  INFRACOST_LOG_LEVEL: debug

jobs:
  terraform-project:
    name: Infracost
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    env:
      TF_ROOT: terragrunt/

    steps:
      - name: add GIT_SSH_KEY
        run: |
          ssh-agent -a $SSH_AUTH_SOCK
          mkdir -p ~/.ssh
          echo "${{ secrets.TERRAFORM_MODULES_SSH_KEY }}" | tr -d '\r' | ssh-add -
          ssh-keyscan <http://github.com|github.com> >> ~/.ssh/known_hosts

      - name: Setup Infracost
        uses: infracost/actions/setup@v2
        with:
          api-key: ${{ secrets.INFRACOST_API_KEY }}

      - name: Checkout base branch
        uses: actions/checkout@v3
        with:
          ref: '${{ github.event.pull_request.base.ref }}'

      - name: Generate Infracost cost estimate baseline
        run: |
          infracost breakdown --path=${TF_ROOT} \
                              --format=json \
                              --out-file=/tmp/infracost-base.json

      - name: Checkout PR branch
        uses: actions/checkout@v3

      - name: Generate Infracost diff
        run: |
          infracost diff --path=${TF_ROOT} \
                              --format=json \
                              --compare-to=/tmp/infracost-base.json \
                              --out-file=/tmp/infracost.json
          cat /tmp/infracost.json

      - name: Post Infracost comment
        run: |
          infracost comment github --path=/tmp/infracost.json \
                                   --repo=$GITHUB_REPOSITORY \
                                   --github-token=${{github.token}} \
                                   --pull-request=${{github.event.pull_request.number}} \
                                   --behavior=update

Hi Diego, can you share an example of the hcl and the change you’re making?

sure, i changed the

desired_count

to 10 instead 1

inputs = {
  container = {
    image_uri               = var.registry_url
    name                    = "floorplan"
    port                    = 8080
    protocol                = "HTTP"
    cpu                     = 1024
    memory                  = 2048
    desired_count           = 1
    environment             = local.app_vars

sorry I’m not super familiar with the ecs, do you have a more complete example with the resource blocks, etc?

no worries, if i change the CPU and Memory as well, like that:

inputs = {
  container = {
    image_uri               = var.registry_url
    name                    = "floorplan"
    port                    = 8080
    protocol                = "HTTP"
    cpu                     = 4096
    memory                  = 16384
    desired_count           = 1
    environment             = local.app_vars

No changes in the cost estimation as well

yeah I get that you’re changing the terragrunt module inputs, but without knowing more about the module it’s hard to figure out what’s going on. Maybe the best I can say is that I agree it’s weird that changing the desired count isn’t changing the cost. Do we give any cost for that service? Maybe we’re not detecting it as fargate for some reason.

Hi tim, sorry about the delay

Hmm the docs to that module say “`desired_count`/`scale` is always ignored; the module is designed to utilize autoscaling by default (though it can be disabled)” so maybe that’s why the cost doesn’t change?

yes, however if this is changed from 1 to 10, in theory Fargate billing will increase in the same order. Since billing increases, I assume Infracost should detect this.

Ok two questions: 1. If you just urn infracost breakdown from the cli do you get a non-zero estimate?

1. when i performed the command:

infracost breakdown --path . --format json --out-file infracost-base.json

Changed the

desired_count

from 1 to 10 and run:

infracost diff --path . --compare-to infracost-base.json

the result is always the same

I understand it’s the same, but is there an estimate at all? For example when i run

infracost breakdown --path .

against the example module I get:

module.ecs_service.module.container_definition["fluent-bit"].aws_cloudwatch_log_group.this[0]                                                                
 ├─ Data ingested                                                                               Monthly cost depends on usage: $0.50 per GB                   
 ├─ Archival Storage                                                                            Monthly cost depends on usage: $0.03 per GB                   
 └─ Insights queries data scanned                                                               Monthly cost depends on usage: $0.005 per GB

Which means there was no estimate generated (because there was no task definition).

i can see some estimations like that:

Name                                                                                                     Monthly Qty  Unit                  Monthly Cost 
                                                                                                                                                          
 aws_route53_record.lb_record                                                                                                                             
 ├─ Standard queries (first 1B)                                                                      Monthly cost depends on usage: $0.40 per 1M queries  
 ├─ Latency based routing queries (first 1B)                                                         Monthly cost depends on usage: $0.60 per 1M queries  
 └─ Geo DNS queries (first 1B)                                                                       Monthly cost depends on usage: $0.70 per 1M queries  
                                                                                                                                                          
 module.alb.aws_lb.this[0]                                                                                                                                
 ├─ Application load balancer                                                                                     730  hours                       $18.40 
 └─ Load balancer capacity units                                                                     Monthly cost depends on usage: $5.84 per LCU         
                                                                                                                                                          
 module.ecs_service.module.container_definition["admin-ui"].aws_cloudwatch_log_group.this[0]                                                              
 ├─ Data ingested                                                                                    Monthly cost depends on usage: $0.57 per GB          
 ├─ Archival Storage                                                                                 Monthly cost depends on usage: $0.03 per GB          
 └─ Insights queries data scanned                                                                    Monthly cost depends on usage: $0.0057 per GB

but the infracosts shows the same estimation value, regardless about the number of containers, the value is always the same.

Yeah I guess it’s a little confusing, but there is no estimate for the ec2_service. The estimate is based on the aws_ec2_task_definition, so we must not be able to determine what that is for some reason. If we picked up the task definition the estimate would look like:

module.ecs_service.aws_ecs_service.this[0]                                                                           
 ├─ Per GB per hour                                                       2  GB                                 $6.49 
 ├─ Per vCPU per hour                                                     1  CPU                               $29.55 
 └─ Inference accelerator (eia2.medium)                                 730  hours                             $87.60

Do you think I should run a terragrunt plan, export the result in JSON file, and then perform the infracost diff?

I might try that locally first just to see if you get any estimate at all (since you’re not getting one with just the hcl). Other than that, it’s really hard to tell what’s going on without an example of how the task definitions are being passed to the module. If they’re generated dynamically or from a data block somehow, there may not be a way for us to provide an estimate.

Hi Tim, today I've tried to perform a

terragrunt run-all plan -out planfile

in the main branch (with 1 container) and run the same plan on my test branch (10 containers). No changes has been detected 😢

Oh well it was worth a shot. Like I said the estimates are based off task definitions, not containers, but unfortunately I out of ideas without having a complete example to look at.

okay, i'll try to investigate deeply. Thanks for the help and for all informations provided 🙏