# AWS-Fargate-Preisrechner

Kostenlos, im Browser · Preise geprüft am 17. November 2026, us-east-1

## Fargate-Preisrechner

### Formel anzeigen

```
Per task-hour = vCPU × price per vCPU-hour + GB × price per GB-hour
              (+ vCPU × Windows licence fee) (+ storage GB above 20 × storage price)
Monthly cost  = task-hours × per task-hour
```

Preise geprüft am 17. November 2026, us-east-1, On-Demand, in US-Dollar. Andere Regionen weichen ab. Durchgehend bedeutet 730 Stunden pro Monat, wie im AWS Pricing Calculator. Alles wird in Ihrem Browser berechnet.

Screenshot: Cost by resource: geschätzte Monatssumme und Ressourcen nach Kosten sortiert

In der App CloudConsole

## Führen Sie das auf Ihrem eigenen Konto aus

Für bereits laufende Services multipliziert die Karte „Monthly cost“ der App bei einem ECS-Service auf Fargate seine Task-Größe mit den aktuell laufenden Tasks zum Preis Ihrer Region, und Cost by resource ordnet ihn zusammen mit Ihren Instanzen, Datenbanken und NAT-Gateways.

[So funktioniert Cost by resource → (EN)](https://cloudconsole.dev/app-tools/aws-cost-per-resource)

[Laden im App Store](https://apps.apple.com/app/cloudconsole-for-aws/id6835419710) · [Bei Google Play laden](https://play.google.com/store/apps/details?id=com.cloudconsole.app)

**Kurze Antwort**

Fargate berechnet die vCPU und den Arbeitsspeicher, die ein Task anfordert, sekundengenau mit 1 Minute Mindestdauer: $0.04048 pro vCPU-Stunde und $0.004445 pro GB-Stunde für Linux/x86 in us-east-1, auf Arm etwa 20 % weniger. Ein Task mit 1 vCPU und 2 GB kostet $0.04937 pro Stunde oder etwa $36.04 pro Monat im Dauerbetrieb. Windows kommt mit Lizenzgebühr und 5 Minuten Mindestdauer; kurzlebiger Speicher über 20 GB kostet extra.

## So funktioniert die Preisgestaltung von AWS Fargate

Fargate berechnet, was jeder ECS-Task (oder EKS-Pod) *anfordert*, nicht was er nutzt: vCPU und Arbeitsspeicher des Tasks, sein Betriebssystem und seine CPU-Architektur sowie kurzlebigen Speicher über den 20 GB, die jeder Task erhält. Abgerechnet wird ab dem Moment, in dem der Task sein Container-Image zu ziehen beginnt, bis er stoppt, auf die nächste Sekunde aufgerundet.

```
cost per task-hour = vCPU × price per vCPU-hour
                   + memory (GB) × price per GB-hour
                   + vCPU × Windows licence fee        (Windows only)
                   + (ephemeral storage GB − 20) × $0.000111
monthly cost       = cost per task-hour × task-hours a month
```

Ein Task, der kürzer als die Mindestdauer läuft, wird mit der Mindestdauer berechnet: **1 Minute unter Linux, 5 Minuten unter Windows**. Das zählt bei kurzen geplanten Jobs. Ein Linux-Job, der jede Minute 20 Sekunden läuft, wird abgerechnet, als liefe er durchgehend, und ein 2-minütiger Windows-Job kostet so viel wie ein 5-minütiger.

Weil die Rechnung der Task-Größe folgt, ist die günstigste Einstellung die kleinste Größe, in die Ihre Container passen. CPUUtilization und MemoryUtilization in CloudWatch zeigen, wie viel von jedem Task genutzt wird; ein Service, der bei 4 vCPU auf 10 % CPU sitzt, zahlt für mehr als 3 vCPU, die er nicht nutzt.

## Fargate-Preise in us-east-1

Preise geprüft am 17. November 2026 für USA Ost (Nord-Virginia), On-Demand, aus der AWS Price List und der Preisseite von Fargate. AWS rechnet ein GB als 1024³ Byte.

| Gebühr | Linux/x86 | Linux/Arm | Windows/x86 |
|---|---|---|---|
| Pro vCPU-Stunde | $0.04048 | $0.03238 | $0.046552 |
| Pro GB-Stunde Arbeitsspeicher | $0.004445 | $0.00356 | $0.00511175 |
| Windows-Lizenz, pro vCPU-Stunde | — | — | $0.046 |
| Kurzlebiger Speicher über 20 GB, pro GB-Stunde | $0.000111 | $0.000111 | $0.000111 |
| Mindestgebühr pro Task | 1 Minute | 1 Minute | 5 Minuten |

### Monatliche Kosten gängiger Task-Größen

Ein Task, der den ganzen Monat läuft (730 Stunden), mit den enthaltenen 20 GB Speicher:

| Task-Größe | Linux/x86 | Linux/Arm | Windows/x86 |
|---|---|---|---|
| 0.25 vCPU, 0.5 GB | $9.01 | $7.21 | — |
| 0.25 vCPU, 1 GB | $10.63 | $8.51 | — |
| 0.5 vCPU, 1 GB | $18.02 | $14.42 | — |
| 1 vCPU, 2 GB | $36.04 | $28.84 | $75.03 |
| 1 vCPU, 4 GB | $42.53 | $34.03 | $82.49 |
| 2 vCPU, 4 GB | $72.08 | $57.67 | $150.05 |
| 2 vCPU, 8 GB | $85.06 | $68.07 | $164.98 |
| 4 vCPU, 8 GB | $144.16 | $115.34 | $300.10 |
| 4 vCPU, 16 GB | $170.12 | $136.13 | $329.96 |
| 8 vCPU, 16 GB | $288.32 | $230.68 | — |
| 16 vCPU, 32 GB | $576.64 | $461.36 | — |

## Gültige CPU- und Speicherkombinationen für Fargate

Fargate führt nur die folgenden Task-Größen aus. Der Rechner rastet darauf ein: Wählen Sie einen vCPU-Wert, und die Speicherliste zeigt, was diese Größe erlaubt. In Task-Definitionen wird die CPU auch in CPU-Einheiten angegeben (1 vCPU = 1024).

| vCPU (CPU-Einheiten) | Arbeitsspeicher | Betriebssysteme |
|---|---|---|
| 0.25 vCPU (256) | 0.5, 1 oder 2 GB | Linux |
| 0.5 vCPU (512) | 1, 2, 3 oder 4 GB | Linux |
| 1 vCPU (1024) | 2–8 GB in Schritten von 1 GB | Linux, Windows |
| 2 vCPU (2048) | 4–16 GB in Schritten von 1 GB | Linux, Windows |
| 4 vCPU (4096) | 8–30 GB in Schritten von 1 GB | Linux, Windows |
| 8 vCPU (8192) | 16–60 GB in Schritten von 4 GB | Linux |
| 16 vCPU (16384) | 32–120 GB in Schritten von 8 GB | Linux |
| 32 vCPU (32768) | 60, 120 oder 244 GB | Linux |

8, 16 und 32 vCPU brauchen die Linux-Plattformversion 1.4.0 oder neuer. Windows-Tasks brauchen mindestens 1 vCPU und laufen nur auf x86. Der kurzlebige Speicher lässt sich von standardmäßig 20 GB auf 200 GB pro Task erhöhen.

## ECS oder EKS, Arm, Spot und Savings Plans

- **EKS auf Fargate.** Die Fargate-Preisseite von AWS berechnet EKS-Pods mit denselben vCPU- und Speicherpreisen wie ECS-Tasks. Jeder Pod wird nach Addition von 256 MB für Kubernetes-Komponenten auf die nächste Größe der Tabelle oben aufgerundet, ein Pod mit 1 vCPU und 8 GB läuft und wird also als 2 vCPU und 9 GB abgerechnet. Windows und Arm gibt es nur auf ECS.
- **Arm (Graviton).** Etwa 20 % günstiger als x86, für vCPU wie Arbeitsspeicher. Images brauchen einen arm64- (oder Multi-Arch-)Build.
- **Fargate Spot.** Unterbrechbare Kapazität für ECS-Tasks unter Linux mit bis zu 70 % Rabatt. Der Preis schwankt mit Angebot und Nachfrage und steht nicht in der AWS Price List, daher ist er im Rechner nicht enthalten.
- **Compute Savings Plans.** Bis zu 50 % Rabatt auf Fargate gegen eine Ausgabenzusage über ein oder drei Jahre. Hier nicht modelliert.

## Was eine Fargate-Workload sonst noch kostet

Der Rechner deckt die Gebühren von Fargate selbst ab. Eine echte Rechnung für einen Container-Service hat meist mehr Posten:

- **Load Balancer.** Ein Application Load Balancer vor einem Service wird pro Stunde und pro LCU abgerechnet.
- **NAT-Gateways und Datenübertragung.** Tasks in privaten Subnetzen ziehen Images und rufen das Internet über ein NAT-Gateway auf, abgerechnet pro Stunde und pro GB, sofern keine VPC-Endpunkte genutzt werden. Verkehr ins Internet kostet extra.
- **Öffentliche IPv4-Adressen.** Tasks mit öffentlicher IP-Adresse zahlen die VPC-Gebühr für öffentliches IPv4.
- **CloudWatch Logs.** Alles, was Container über den awslogs-Treiber schreiben, wird erfasst und gespeichert.
- **Amazon ECR.** Speicher für Images und Datenübertragung bei Pulls von außerhalb der Region.

Um zu sehen, was Sie tatsächlich ausgeben, gruppieren Sie Cost Explorer nach Service und dann nach Nutzungsart; die [Anleitung zur Aufschlüsselung der AWS-Kosten (EN)](https://cloudconsole.dev/how-to/see-aws-cost-breakdown) zeigt, wie, und die [AWS-Ratgeber (EN)](https://cloudconsole.dev/guides/) behandeln den Rest der Rechnung.

**Fargate oder Lambda?** Einen direkten Vergleichswert gibt es hier nicht: Lambda rechnet pro Anfrage und pro GB-Sekunde jedes Aufrufs ab, mit an den Speicher gekoppelter CPU, die Kosten derselben Arbeit hängen also vom Verkehr ab, nicht von einer Task-Größe. Nutzen Sie zum Vergleich den [Lambda-Kostenrechner](https://cloudconsole.dev/de/tools/lambda-cost-calculator) mit Ihrer Anfragerate und Laufzeit.

## Häufige Fragen

### Wie wird AWS Fargate abgerechnet?

Fargate berechnet die vCPU und den Arbeitsspeicher, die ein Task anfordert, sekundengenau, ab dem Moment, in dem er das Container-Image zu ziehen beginnt, bis der Task stoppt, mit 1 Minute Mindestdauer unter Linux. In us-east-1 kostet Linux/x86 $0.04048 pro vCPU-Stunde und $0.004445 pro GB-Stunde. Windows kommt mit einer Betriebssystem-Lizenzgebühr pro vCPU-Stunde und 5 Minuten Mindestdauer.

### Was kostet ein Fargate-Task pro Monat?

Ein Task mit 1 vCPU und 2 GB, der den ganzen Monat läuft (730 Stunden), kostet in us-east-1 etwa $36.04 unter Linux/x86, $28.84 unter Linux/Arm und $75.03 unter Windows. Der kleinste Task, 0.25 vCPU und 0.5 GB, kostet unter Linux/x86 etwa $9.01 pro Monat.

### Ist Fargate auf Arm (Graviton) günstiger?

Ja, um etwa 20 %: Linux/Arm kostet in us-east-1 $0.03238 pro vCPU-Stunde und $0.00356 pro GB-Stunde, gegenüber $0.04048 und $0.004445 unter Linux/x86. Ihre Container-Images brauchen einen arm64-Build, und Windows-Tasks können nur x86 nutzen.

### Kostet EKS auf Fargate dasselbe wie ECS auf Fargate?

Die Fargate-Preisseite von AWS nutzt für EKS-Pods dieselben vCPU- und Speicherpreise wie für ECS-Tasks, und ihr EKS-Beispiel verwendet die Preise für Linux/x86. Auf EKS wird jeder Pod auf die nächste Fargate-Größe aufgerundet, mit 256 MB zusätzlich für Kubernetes-Komponenten, und Windows und Arm gibt es nur auf ECS.

### Und Fargate Spot?

Fargate Spot führt unterbrechbare ECS-Tasks unter Linux mit bis zu 70 % Rabatt aus, aber der Preis ändert sich mit der Zeit und steht nicht in der AWS-Price-List-Datei, die dieser Rechner nutzt, daher ist er nicht modelliert. Prüfen Sie den aktuellen Spot-Preis auf der Preisseite von AWS Fargate.

### Was lässt der Fargate-Preisrechner weg?

Datenübertragung, Load Balancer, NAT-Gateways, öffentliche IPv4-Adressen, CloudWatch Logs, Image-Speicher in Amazon ECR, Fargate Spot und Compute Savings Plans. Er berechnet nur die eigenen Gebühren von Fargate für vCPU, Arbeitsspeicher, Windows-Lizenz und kurzlebigen Speicher.

**Sehen, was Ihre Container kosten**

CloudConsole zeigt Ihre Ausgaben nach Service, mit Nutzungsarten und Regionen, neben Ihren ECS-Clustern, -Services und -Tasks, sodass ein Service, der plötzlich mehr kostet, auffällt. Auf iPhone und Android.

[Über die App →](https://cloudconsole.dev/de/aws-console-app)

## Quellen

- [AWS Fargate pricing](https://aws.amazon.com/fargate/pricing/)
- [AWS Price List: Amazon ECS (Fargate), us-east-1](https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonECS/current/us-east-1/index.json)
- [Amazon ECS task definition differences for Fargate (task CPU and memory)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-tasks-services.html)
- [Fargate task ephemeral storage for Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-task-storage.html)
- [Understand Fargate Pod configuration details (EKS)](https://docs.aws.amazon.com/eks/latest/userguide/fargate-pod-configuration.html)
- [Amazon ECS clusters for Fargate (Fargate Spot)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-capacity-providers.html)

## Weitere Seiten

- [AWS-Lambda-Kostenrechner](https://cloudconsole.dev/de/tools/lambda-cost-calculator) – Kostenlose Tools
- [Einen ECS-Service skalieren (EN)](https://cloudconsole.dev/how-to/scale-ecs-service) – Anleitungen
- [OutOfMemoryError: Container killed due to memory usage (EN)](https://cloudconsole.dev/errors/ecs-outofmemoryerror) – AWS-Fehler beheben
- [CloudWatch-Alarm für CPUUtilization eines Amazon-ECS-Service (EN)](https://cloudconsole.dev/alarms/ecs-cpuutilization) – CloudWatch-Alarme
- [Warum ist meine AWS-Rechnung so hoch? (EN)](https://cloudconsole.dev/how-to/why-is-my-aws-bill-so-high) – Anleitungen
- [Eine Aufschlüsselung der AWS-Kosten anzeigen (EN)](https://cloudconsole.dev/how-to/see-aws-cost-breakdown) – Anleitungen

---

Source: https://cloudconsole.dev/de/tools/fargate-pricing-calculator

CloudConsole is an independent iPhone and Android app for Amazon Web Services by Cloudconcur Ltd. It is not affiliated with Amazon Web Services.
