open-index/open-npm huggingface dataset:
npm package: @raykrueger/cdk-fargate-public-dns
Description: An AWS CDK module that listens for ECS Tasks to enter RUNNING state and then updates a Route 53 hosted zone with the public IP address attached to the task.
Author: Ray Krueger
Latest version: 0.0.22

# @raykrueger/cdk-fargate-public-dns

This is an [AWS Cloud Development Kit](https://aws.amazon.com/cdk/) V2 construct
library to support updating Route 53 entry with the public ip address of an ECS
Fargate task. This is useful if you are, say, running an individual instance of
a game server on ECS Fargate and do not want the added cost of a Network Load
Balancer.

## Usage

This is the simple usecase. You pass an ECS Service and Cluster defined by your
CDK stack. Within the `dnsConfig` block you pass the Route 53 fully qualified
domain name, and the hosted zone ID.

```javascript
import { PublicIPSupport } from '@raykrueger/cdk-fargate-public-dns';

new PublicIPSupport(stack, 'PublicIPSupport', {
    cluster,
    service,
    dnsConfig: {
        domainName: 'www.example.com',
        hostzedZone: 'Z0000000000000000000X',
    },
})
```

## Usage in Another Account

If the hosted zone you want to update is in a different AWS acccount, this
Construct can assume a role in that target account in order to perform the Route
53 Domain update. To do that, simply add the `assumedRole` property to the `dnsConfig`.

```javascript
new PublicIPSupport(stack, 'PublicIPSupport', {
    cluster,
    service,
    dnsConfig: {
        domainName: 'www.example.com',
        hostzedZone: 'Z0000000000000000000X',
        assumedRole: 'arn:aws:iam::<the_other_account_id>:role/<the_role_name_to_assume>'
    },
})
```

In the target account you will need to define the role that this library can assume. You can create a role in the console to trust another AWS account. Then give it these permissions

```json
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "route53:ChangeResourceRecordSets",
                "route53:ListResourceRecordSets"
            ],
            "Resource": [
                "arn:aws:route53:::hostedzone/Z0000000000000000000X"
            ]
        }
    ]
}
```

## How it Works

This CDK Construct deploys an AWS Lambda and an Amazon EventBridge rule. The
rule is defined to look for the `lastStatus` and `desiredStatus` attributes to
be 'RUNNING' of an `ECS Task State Change` event. It is also specifically tied
to the Service and Cluster passed into the constructor.

## I was here

Note that I built this in my free time. This has nothing to do with my employer.

Enjoy! -Ray
npm package: @raykrueger/cdk-valheim-server
Description: A CDK construct library for running a Valheim dedicated server on AWS
Author: Ray Krueger
Latest version: 0.0.14
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# raykrueger/cdk-valheim-server

This is an AWS Cloud Development Kit (CDK) construct library to run a
[Valheim](https://www.valheimgame.com/) dedicated server in AWS Fargate on
Amazon Elastic Container Service (ECS).

**AWS Costs will apply!** This thing won't run for free. See [Costs](#costs) for
more information.

## Summary

This CDK Construct will deploy Valheim using the
[raykrueger/valheim](https://hub.docker.com/r/raykrueger/valheim) Docker
container. The container is deployed to an Amazon ECS Cluster, running on AWS
Fargate. The game world is persisted to Amazon Elastic File System. The game
server is exposed to the internet via a Network Load Balancer.

The server should run with pretty high resilliency. Given that the world is
saved to an EFS file system, and the ECS Cluster is running across multipe
availability zones, the server can die in one Availability Zone and come up
in another with a low risk of loss. This is a beta game, and stuff happens,
so you may want to consider enabling AWS Backup for your EFS filesystem.

## Sample Application

This is the basic CDK Application needed to run the cdk-valheim-server
construct. The easiest way to get started would be to use projen, `npx projen
new awscdk-app-ts`. You'll need NodeJS installed the [AWS
CLI](https://aws.amazon.com/cli/) more than likely.

The default properties for the ValheimServer construct mean it will create a
VPC to run everything, and it will generate a random password to access the
server. The server password will be stored in [AWS Secrets
Manager](https://aws.amazon.com/secrets-manager/) under the name
`ValheimServerPassword`. This can be retrived from the AWS Console, or from
the cli using `aws secretsmanager get-secret-value --secret-id
ValheimServerPassword`.

```typescript
import { App, Construct, Stack, StackProps } from '@aws-cdk/core';
import {ValheimServer} from '@raykrueger/cdk-valheim-server';

export class MyStack extends Stack {
  constructor(scope: Construct, id: string, props: StackProps = {}) {
    super(scope, id, props);

    new ValheimServer(this, 'Valheim');
  }
}

const devEnv = {
  account: process.env.CDK_DEFAULT_ACCOUNT,
  region: process.env.CDK_DEFAULT_REGION,
};

const app = new App();

new MyStack(app, 'Valheim', { env: devEnv });

app.synth();
```

## Costs

See [AWS Fargate Pricing](https://aws.amazon.com/fargate/pricing/) for cost
details in your region. The default confugration deploys 1vcpu and 8gb of
memory. In addtion, you will incur costs for EFS and some amount of network
transfer. Your mileage may vary.


## I was here

Note that I built this in my free time. This has nothing to do with Iron Gate
AB, Coffee Stain Publishing, or my employer.

Enjoy!
-Ray