# Testing AWS Authentication

## Server Configuration

AWS authentication requires the following to be done on the server side:

1. The AWS authentication mechanism must be enabled on the server. This
is done by adding `MONGODB-AWS` to the values in `authenticationMechanisms`
server parameter.

2. A user must be created in the `$external` database with the ARN matching
the IAM user or role that the client will authenticate as.

Note that the server does not need to have AWS keys provided to it - it
uses the keys that the client provides during authentication.

An easy way to configure the deployment in the required fashion is to
configure the deployment to accept both password authentication and
AWS authentication, and add a bootstrap user:

    mlaunch init --single --auth --username root --password toor \
      --setParameter authenticationMechanisms=MONGODB-AWS,SCRAM-SHA-1,SCRAM-SHA-256 \
      --dir /tmp/db

Then connect as the bootstrap user and create AWS-mapped users:

    mongo mongodb://root:toor@localhost:27017
    
    # In the mongo shell:
    use $external
    db.createUser({
      user: 'arn:aws:iam::1234567890:user/test',
      roles: [{role:'root', db:'admin'}]})

The ARN can be retrieved from the AWS management console. Alternatively,
if the IAM user's access and secret keys are known, trying to authenticate
as the user will log the user's ARN into the server log when authentication
fails; this ARN can be then used to create the server user.

With the server user created, it is possible to authenticate using AWS.
The following example uses regular user credentials for an IAM user
created as described in the next section;

    mongo 'mongodb://AKIAAAAAAAAAAAA:t9t2mawssecretkey@localhost:27017/?authMechanism=MONGODB-AWS&authsource=$external'

To authenticate, provide the IAM user's access key id as the username and
secret access key as the password. Note that the username and the password
must be percent-escaped when they are passed in the URI as the examples here
show. Also note that the user's ARN is not explicitly specified by the client
during authentication - the server determines the ARN from the acess
key id and the secret access key provided by the client.

## Provisioning Tools

The Ruby driver includes tools that set up the resources needed to test
AWS authentication. These are exposed by the `.evergreen/aws` script.
To use this script, it must be provided AWS credentials and the region
to operate in. The credentials and region can be given as command-line
arguments or set in the environment, as follows:

    export AWS_ACCESS_KEY_ID=AKIAYOURACCESSKEY
    export AWS_SECRET_ACCESS_KEY=YOURSECRETACCESSKEY
    export AWS_REGION=us-east-1

If you also perform manual testing (for example by following some of the
instructions in this file), ensure AWS_SESSION_TOKEN is not set
unless you are intending to invoke the `.evergreen/aws` script with
temporary credentials:

    unset AWS_SESSION_TOKEN

Note that [AWS CLI](https://aws.amazon.com/cli/) uses a different environment
variable for the region - `AWS_DEFAULT_REGION` rather than `AWS_REGION`.
If you also intend to use the AWS CLI, execute:

    export AWS_DEFAULT_REGION=$AWS_REGION

To verify that credentials are correctly set in the environment, you can
perform the following operations:

    # Test driver tooling
    ./.evergreen/aws key-pairs
    
    # Test AWS CLI
    aws sts get-caller-identity

Alternatively, to provide the credentials on each call to the driver's
`aws` script, use the `-a` and `-s` arguments as follows:

    ./.evergreen/aws -a KEY-ID -s SECRET-KEY key-pairs

## Common Setup

In order to test all AWS authentication scenarios, a large number of AWS
objects needs to be configured. This configuration is split into two parts:
common setup and scenario-specific setup.

The common setup is performed by running:

    ./.evergreen/aws setup-resources

This creates resources like security groups, IAM users and CloudWatch
log groups that do not cost money. It is possible to test authentication
with regular credentials and temporary credentials obtained via an
AssumeRole request using these resources. In order to test authentication
from an EC2 instance or an ECS task, the instance and/or the task need
to be started which costs money and is performed as separate steps as
detailed below.

## Regular Credentials - IAM User

AWS authentication as a regular IAM user requires having an IAM user to
authenticate as. This user can be created using the AWS management console.
The IAM user requires no permissions, but it must have the programmatic
access enabled (i.e. have an access key ID and the secret access key).

An IAM user is created as part of the common setup described earlier.
To reset and retrieve the access key ID and secret access key for the
created user, run:

    ./.evergreen/aws reset-keys

Note that if the user already had an access key, the old credentials are
removed and replaced with new credentials.

Given the credentials for the test user, the URI for running the driver
test suite can be formed as follows:

    export "MONGODB_URI=mongodb://$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY@localhost:27017/?authMechanism=MONGODB-AWS&authsource=$external"

## Temporary Credentials - AssumeRole Request

To test a user authenticating with an assumed role, you can follow
[the example provided in Amazon documentation](https://aws.amazon.com/premiumsupport/knowledge-center/iam-assume-role-cli/)
to set up the assumed role and related objects and obtain temporary credentials
or use the driver's tooling using the commands given below.
Since the temporary credentials expire, the role needs to be re-assumed
periodically during testing and the new credentials and session token retrieved.

If following the example in Amazon's documentation,
[jq](https://stedolan.github.io/jq/) can be used to efficiently place the
credentials from the AssumeRole request into the environment, as follows:

    # Call given in the example guide
    aws sts assume-role --role-arn arn:aws:iam::YOUR-ACCOUNT-ID:role/example-role --role-session-name AWSCLI-Session >~/.aws-assumed-role.json
    
    # Extract the credentials
    export AWS_ACCESS_KEY_ID=`jq .Credentials.AccessKeyId  ~/.aws-assumed-role.json -r`
    export AWS_SECRET_ACCESS_KEY=`jq .Credentials.SecretAccessKey  ~/.aws-assumed-role.json -r`
    export AWS_SESSION_TOKEN=`jq .Credentials.SessionToken ~/.aws-assumed-role.json -r`

Alternatively, the `./evergreen/aws` script can be used to assume the role.
By default, it will assume the role that `setup-resources` action configured.

Note: The ability to assume this role is granted to the
[IAM user](#regular-credentials-iam-user) that the provisioning tool creates.
Therefore the shell must be configured with credentials of the test user,
not with credentials of the master user that performed the provisioning.

To assume the role created by the common setup, run:

    ./.evergreen/aws assume-role

It is also possible to specify the ARN of the role to assume manually, if
you created the role using other means:

    ./.evergreen/aws assume-role ASSUME-ROLE-ARN

To place the credentials into the environment:

    eval $(./.evergreen/aws assume-role)
    export AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN

With the credentials in the environment, to verify that the role was assumed
and the credentials are complete and correct, perform a `GetCallerIdentity`
call:

    aws sts get-caller-identity

Given the credentials for the test user, the URI for running the driver
test suite can be formed as follows:

    export "MONGODB_URI=mongodb://$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY@localhost:27017/?authMechanism=MONGODB-AWS&authsource=$external&authMechanismProperties=AWS_SESSION_TOKEN:$AWS_SESSION_TOKEN"

## Temporary Credentials - EC2 Instance Role

To test authentication [using temporary credentials for an EC2 instance
role](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html),
an EC2 instance launched with an IAM role or an EC2 instance configured
with an instance profile is required. No permissions are needed for the
IAM role used with the EC2 instance.

To create an EC2 instance with an attached role using the AWS console:

1. Crate an IAM role that the instance will use. It is not necessary to
specify any permissions.
2. Launch an instance, choosing the IAM role created in the launch wizard.

To define an instance profile which allows adding and removing an IAM role
to/from an instance at runtime, follow Amazon documentation
[here](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
To test temporary credentials obtained via an EC2 instance role in Evergreen,
an instance profile must be associated with the running instance as per
this guide.

The driver provides tooling to configure a suitable instance profile and
launch an EC2 instance that can have this instance profile attached to it.

The instance profile and associated IAM role are created by the common
setup described above. To launch an EC2 instance suitable for testing
authentication via an EC2 role, run:

    ./.evergreen/aws launch-ec2 path/to/ssh.key.pub

The `launch-ec2` command takes one argument which is the path to the
public key for the key pair to use for SSH access to the instance.

This script will output the instance ID of the launched instance. The
instance initially does not have an instance profile assigned; to assign
the instance profile created in the common setup to the instance, run:

    ./.evergreen/aws set-instance-profile i-instanceid

To remove the instance profile from the instance, run:

    ./.evergreen/aws clear-instance-profile i-instanceid

To provision the instance for running the driver's test suite via Docker, run:

    ip=12.34.56.78
    ./.evergreen/provision-remote ubuntu@$ip docker

To run the AWS auth tests using the EC2 instance role credentials, run:

    ./.evergreen/test-docker-remote ubuntu@$ip \
      MONGODB_VERSION=4.4 AUTH=aws-ec2 \
      -s .evergreen/run-tests-aws-auth.sh \
      -a .env.private

Note that if if you are not using MongoDB AWS account for testing, you
would need to specify MONGO_RUBY_DRIVER_AWS_AUTH_USER_ARN in your
`.env.private` file with the ARN of the user to add to MongoDB. The easiest
way to find out this value is to run the tests and note which username the
test suite is trying to authenticate as.

To terminate the instance, run:

    ./.evergreen/aws stop-ec2

## Temporary Credentials - ECS Task Role

The basic procedure for setting up an ECS cluster is described in
[this guide](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_AWSCLI_Fargate.html).
For testing AWS auth, the ECS task must have a role assigned to it which is
covered in [this guide](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)
and additionally [here](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html).

Although not required for testing AWS auth specifically, it is very helpful
for general troubleshooting of ECS provisioning to have log output from the
tasks. Logging to CloudWatch is covered by [this Amazon guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/QuickStartEC2Instance.html)
with these potentially helpful [additional](https://stackoverflow.com/questions/50397217/how-to-determine-the-cloudwatch-log-stream-for-a-fargate-service#50704804)
[resources](https://help.sumologic.com/03Send-Data/Collect-from-Other-Data-Sources/AWS_Fargate_log_collection).
A log group must be manually created, the steps for which are described
[here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html).

Additional references:

- [Task definition CPU and memory values](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html)

The common setup creates all of the necessary prerequisites to test
authentication using ECS task credentials, which includes an empty ECS
cluster. To test authentication, a service needs to be created in the
ECS cluster that runs the SSH daemon, which can be done by running:

    ./.evergreen/aws launch-ecs path/to/ssh.key.pub

The `launch-ecs` command takes one argument which is the path to the
public key for the key pair to use for SSH access to the instance.

This script generally produces no output if it succeeds. As the service takes
some time to start, run the following command to check its status:

    ./.evergreen/aws ecs-status

The status output shows the tasks running in the ECS cluster ordered by their
generation, with the newest ones first. Event log for the cluster is displayed,
as well as event stream for the running task of the latest available generation
which includes the Docker execution output collected via CloudWatch.
The status output includes the public IP of the running task once it is
available, which can be used to SSH into the container and run the tests.

Note that when AWS auth from an ECS task is tested in Evergreen, the task is
accessed via its private IP; when the test is performed using the provisioning
tooling described in this document, the task is accessed via its public IP.

If the public IP address is in the `IP` shell variable, provision the task:

    ./.evergreen/provision-remote root@$IP local

To run the credentials retrieval test on the ECS task, execute:

    ./.evergreen/test-remote root@$IP env AUTH=aws-ecs RVM_RUBY=ruby-2.7 MONGODB_VERSION=4.4 TEST_CMD='rspec spec/integration/aws*spec.rb' .evergreen/run-tests.sh

To run the test again without rebuilding the remote environment, execute:

    ./.evergreen/test-remote -e root@$IP \
      env AUTH=aws-ecs RVM_RUBY=ruby-2.7 sh -c '\
        export PATH=`pwd`/rubies/ruby-2.7/bin:$PATH && \
        eval export `strings /proc/1/environ |grep ^AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` && \
        bundle exec rspec spec/integration/aws*spec.rb'

Note that this command retrieves the value of `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`
from the PID 1 environment and places it into the current environment prior to
running the tests.

To terminate the AWS auth-related ECS tasks, run:

    ./.evergreen/aws stop-ecs