Kubernetes on AWS

We will show you step by step on how to run distributed PaddlePaddle training on AWS cluster with Kubernetes. Let’s start from core concepts.

Distributed PaddlePaddle Training Core Concepts

Distributed Training Job

A distributed training job is represented by a Kubernetes job.

Each Kuberentes job is described by a job config file, which specifies the information like the number of pods in the job and environment variables.

In a distributed training job, we would:

1. prepare partitioned training data and configuration file on a distributed file system (in this tutorial we use Amazon Elastic File System), and
2. create and submit the Kubernetes job config to the Kubernetes cluster to start the training job.

Parameter Servers and Trainers

There are two roles in a PaddlePaddle cluster: parameter server (pserver) and trainer. Each parameter server process maintains a shard of the global model. Each trainer has its local copy of the model, and uses its local data to update the model. During the training process, trainers send model updates to parameter servers, parameter servers are responsible for aggregating these updates, so that trainers can synchronize their local copy with the global model.

In order to communicate with pserver, trainer needs to know the ip address of each pserver. In kubernetes it’s better to use a service discovery mechanism (e.g., DNS hostname) rather than static ip address, since any pserver’s pod may be killed and a new pod could be schduled onto another node of different ip address. However, now we are using static ip. This will be improved.

Parameter server and trainer are packaged into a same docker image. They will run once pod is scheduled by kubernetes job.

Trainer ID

Each trainer process requires a trainer ID, a zero-based index value, passed in as a command-line parameter. The trainer process thus reads the data partition indexed by this ID.

Training

The entry-point of a container is a shell script. It can see some environment variables pre-defined by Kubernetes. This includes one that gives the job’s identity, which can be used in a remote call to the Kubernetes apiserver that lists all pods in the job.

We rank each pod by sorting them by their ips. The rank of each pod could be the “pod ID”. Because we run one trainer and one parameter server in each pod, we can use this “pod ID” as the trainer ID. A detailed workflow of the entry-point script is as follows:

1. Query the api server to get pod information, and assign the trainer_id by sorting the ip.
2. Copy the training data from EFS persistent volume into container.
3. Parse the paddle pserver and paddle trainer startup parameters from environment variables, and then start up the processes.
4. Trainer with train_id 0 will automatically write results onto EFS volume.

PaddlePaddle on AWS with Kubernetes

Choose AWS Service Region

This tutorial requires several AWS services work in the same region. Before we create anything in AWS, please check the following link https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/ Choose a region which has the following services available: EC2, EFS, VPS, CloudFormation, KMS, VPC, S3. In this tutorial, we use “Oregon(us-west-2)” as example.

Create AWS Account and IAM Account

Under each AWS account, we can create multiple IAM users. This allows us to grant some privileges to each IAM user and to create/operate AWS clusters as an IAM user.

To sign up an AWS account, please follow this guide. To create IAM users and user groups under an AWS account, please follow this guide.

Please be aware that this tutorial needs the following privileges for the user in IAM:

• AmazonEC2FullAccess
• AmazonS3FullAccess
• AmazonRoute53FullAccess
• AmazonRoute53DomainsFullAccess
• AmazonElasticFileSystemFullAccess
• AmazonVPCFullAccess
• IAMUserSSHKeys
• IAMFullAccess
• NetworkAdministrator
• AWSKeyManagementServicePowerUser

Download kube-aws and kubectl

kube-aws

kube-aws is a CLI tool to automate cluster deployment to AWS.

Verify kube-aws integrity

Note: if you are using a non-official release (e.g RC release) kube-aws, you can skip this setp. Import the CoreOS Application Signing Public Key:

gpg2 --keyserver pgp.mit.edu --recv-key FC8A365E

Validate the key fingerprint:

gpg2 --fingerprint FC8A365E

The correct key fingerprint is 18AD 5014 C99E F7E3 BA5F 6CE9 50BD D3E0 FC8A 365E

We can download kube-aws from its release page. In this tutorial, we use version 0.9.1

Validate the tarball’s GPG signature:

PLATFORM=linux-amd64
 # Or
PLATFORM=darwin-amd64

gpg2 --verify kube-aws-${PLATFORM}.tar.gz.sig kube-aws-${PLATFORM}.tar.gz

Install kube-aws

Extract the binary:

tar zxvf kube-aws-${PLATFORM}.tar.gz

Add kube-aws to your path:

mv ${PLATFORM}/kube-aws /usr/local/bin

kubectl

kubectl is a command line interface for running commands against Kubernetes clusters.

Download kubectl from the Kubernetes release artifact site with the curl tool.

# OS X
curl -O https://storage.googleapis.com/kubernetes-release/release/"$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)"/bin/darwin/amd64/kubectl

# Linux
curl -O https://storage.googleapis.com/kubernetes-release/release/"$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)"/bin/linux/amd64/kubectl

Make the kubectl binary executable and move it to your PATH (e.g. /usr/local/bin):

chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl

Configure AWS Credentials

First check out this for installing the AWS command line interface.

And then configure your AWS account information:

aws configure

Fill in the required fields:

AWS Access Key ID: YOUR_ACCESS_KEY_ID
AWS Secrete Access Key: YOUR_SECRETE_ACCESS_KEY
Default region name: us-west-2
Default output format: json

YOUR_ACCESS_KEY_ID, and YOUR_SECRETE_ACCESS_KEY is the IAM key and secret from Create AWS Account and IAM Account

Verify that your credentials work by describing any instances you may already have running on your account:

aws ec2 describe-instances

Define Cluster Parameters

EC2 key pair

The keypair that will authenticate SSH access to your EC2 instances. The public half of this key pair will be configured on each CoreOS node.

Follow EC2 Keypair User Guide to create a EC2 key pair

After creating a key pair, you will use the key pair name to configure the cluster.

Key pairs are only available to EC2 instances in the same region. We are using us-west-2 in our tutorial, so make sure to creat key pairs in that region (Oregon).

Your browser will download a key-name.pem file which is the key to access the EC2 instances. We will use it later.

KMS key

Amazon KMS keys are used to encrypt and decrypt cluster TLS assets. If you already have a KMS Key that you would like to use, you can skip creating a new key and provide the Arn string for your existing key.

You can create a KMS key with the aws command line tool:

aws kms --region=us-west-2 create-key --description="kube-aws assets"
{
    "KeyMetadata": {
        "CreationDate": 1458235139.724,
        "KeyState": "Enabled",
        "Arn": "arn:aws:kms:us-west-2:aaaaaaaaaaaaa:key/xxxxxxxxxxxxxxxxxxx",
        "AWSAccountId": "xxxxxxxxxxxxx",
        "Enabled": true,
        "KeyUsage": "ENCRYPT_DECRYPT",
        "KeyId": "xxxxxxxxx",
        "Description": "kube-aws assets"
    }
}

We will need to use the value of Arn later.

And then let’s add several inline policies in your IAM user permission.

Go to IAM Console. Click on button Users, click user that we just created, and then click on Add inline policy button, and select Custom Policy.

Paste into following inline policies:

 (Caution: node_0, node_1, node_2 directories represents PaddlePaddle node and train_id, not the Kubernetes node){
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "Stmt1482205552000",
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt",
                "kms:Encrypt"
            ],
            "Resource": [
                "arn:aws:kms:*:AWS_ACCOUNT_ID:key/*"
            ]
        },
        {
            "Sid": "Stmt1482205746000",
            "Effect": "Allow",
            "Action": [
                "cloudformation:CreateStack",
                "cloudformation:UpdateStack",
                "cloudformation:DeleteStack",
                "cloudformation:DescribeStacks",
                "cloudformation:DescribeStackResource",
                "cloudformation:GetTemplate",
                "cloudformation:DescribeStackEvents"
            ],
            "Resource": [
                "arn:aws:cloudformation:us-west-2:AWS_ACCOUNT_ID:stack/MY_CLUSTER_NAME/*"
            ]
        }
    ]
}

Version : Its value has to be exactly “2012-10-17”. AWS_ACCOUNT_ID: You can get it from following command line:

aws sts get-caller-identity --output text --query Account

MY_CLUSTER_NAME: Pick a MY_CLUSTER_NAME that you like, you will use it later as well. Please note, stack name must satisfy regular expression pattern: [a-zA-Z][-a-zA-Z0-9], which means no “_” or “-” in stack name, or kube-aws will throw error in later steps.

External DNS name

When the cluster is created, the controller will expose the TLS-secured API on a DNS name.

DNS name should have a CNAME points to cluster DNS name or an A record points to the cluster IP address.

We will need to use DNS name later in tutorial. If you don’t already own one, you can choose any DNS name (e.g., paddle) and modify /etc/hosts to associate cluster IP with that DNS name for your local machine. And add name service (route53) in aws to associate the IP to paddle for cluster. We will find the cluster IP in later steps.

S3 bucket

You need to create an S3 bucket before startup the Kubernetes cluster.

There are some bugs in aws cli in creating S3 bucket, so let’s use the S3 Console.

Click on Create Bucket, fill in a unique BUCKET_NAME, and make sure region is us-west-2 (Oregon).

Initialize Assets

Create a directory on your local machine to hold the generated assets:

$ mkdir my-cluster
$ cd my-cluster

Initialize the cluster CloudFormation stack with the KMS Arn, key pair name, and DNS name from the previous step:

kube-aws init \
--cluster-name=MY_CLUSTER_NAME \
--external-dns-name=MY_EXTERNAL_DNS_NAME \
--region=us-west-2 \
--availability-zone=us-west-2a \
--key-name=KEY_PAIR_NAME \
--kms-key-arn="arn:aws:kms:us-west-2:xxxxxxxxxx:key/xxxxxxxxxxxxxxxxxxx"

MY_CLUSTER_NAME: the one you picked in KMS key

MY_EXTERNAL_DNS_NAME: see External DNS name

KEY_PAIR_NAME: see EC2 key pair

--kms-key-arn: the “Arn” in KMS key

Here us-west-2a is used for parameter --availability-zone, but supported availability zone varies among AWS accounts.

Please check if us-west-2a is supported by aws ec2 --region us-west-2 describe-availability-zones, if not switch to other supported availability zone. (e.g., us-west-2a, or us-west-2b)

There will now be a cluster.yaml file in the asset directory. This is the main configuration file for your cluster.

By default kube-aws will only create one worker node. Let’s edit cluster.yaml and change workerCount from 1 to 3.

Render contents of the asset directory

In the simplest case, you can have kube-aws generate both your TLS identities and certificate authority for you.

kube-aws render credentials --generate-ca

The next command generates the default set of cluster assets in your asset directory.

kube-aws render stack

Assets (templates and credentials) that are used to create, update and interact with your Kubernetes cluster will be created under your current folder.

Kubernetes Cluster Start Up

Create the instances defined in the CloudFormation template

Now let’s create your cluster (choose any PREFIX for the command below):

kube-aws up --s3-uri s3://BUCKET_NAME/PREFIX

BUCKET_NAME: the bucket name that you used in S3 bucket

Configure DNS

You can invoke kube-aws status to get the cluster API endpoint after cluster creation.

$ kube-aws status
Cluster Name:       paddle-cluster
Controller DNS Name:    paddle-cl-ElbAPISe-EEOI3EZPR86C-531251350.us-west-2.elb.amazonaws.com

If you own a DNS name, set the A record to any of the above ip. Or you can set up CNAME point to Controller DNS Name (paddle-cl-ElbAPISe-EEOI3EZPR86C-531251350.us-west-2.elb.amazonaws.com)

Find IP address

Use command dig to check the load balancer hostname to get the ip address.

$ dig paddle-cl-ElbAPISe-EEOI3EZPR86C-531251350.us-west-2.elb.amazonaws.com

;; QUESTION SECTION:
;paddle-cl-ElbAPISe-EEOI3EZPR86C-531251350.us-west-2.elb.amazonaws.com. IN A

;; ANSWER SECTION:
paddle-cl-ElbAPISe-EEOI3EZPR86C-531251350.us-west-2.elb.amazonaws.com. 59 IN A 54.241.164.52
paddle-cl-ElbAPISe-EEOI3EZPR86C-531251350.us-west-2.elb.amazonaws.com. 59 IN A 54.67.102.112

In the above output, both ip 54.241.164.52, 54.67.102.112 will work.

If you own a DNS name, set the A record to any of the above ip. Then you can skip to the step “Access the cluster”.

If you do not own a DNS name:

Update local DNS association

Edit /etc/hosts to associate above ip with the DNS name.

Add Route53 private name service in VPC

• Open Route53 Console

• Create hosted zone with following config

  • Domain name: “paddle”
  • Type: “Private hosted zone for amazon VPC”
  • VPC ID: <Your VPC ID>

  

• Add A record

  • Click on the zone “paddle” just created

  • Click the button “Create record set”

    • Name : leave blank
    • type: “A”
    • Value: <kube-controller ec2 private ip>

    

• Verify name service

  • Connect to any instance created by kube-aws via ssh
  • Run command “host paddle”, see if the ip returned is the private ip of kube-controller

Access the cluster

Once the API server is running, you should see:

$ kubectl --kubeconfig=kubeconfig get nodes 
NAME                                       STATUS    AGE
ip-10-0-0-134.us-west-2.compute.internal   Ready     6m
ip-10-0-0-238.us-west-2.compute.internal   Ready     6m
ip-10-0-0-50.us-west-2.compute.internal    Ready     6m
ip-10-0-0-55.us-west-2.compute.internal    Ready     6m

Setup Elastic File System for Cluster

Training data is usually served on a distributed filesystem, we use Elastic File System (EFS) on AWS.

1. Create security group for EFS in security group console
2. Look up security group id for paddle-cluster-sg-worker (sg-055ee37d in the image below)
3. Add security group paddle-efs with ALL TCP inbound rule and custom source as group id of paddle-cluster-sg-worker. And VPC of paddle-cluster-vpc. Make sure availability zone is same as the one you used in Initialize Assets.
4. Create the Elastic File System in EFS console with paddle-cluster-vpc VPC. Make sure subnet is paddle-cluster-Subnet0 andd security group is paddle-efs.

Start PaddlePaddle Training Demo on AWS

Configure Kubernetes Volume that Points to EFS

First we need to create a PersistentVolume to provision EFS volumn.

Save following snippet as pv.yaml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: efsvol
spec:
  capacity:
    storage: 100Gi
  accessModes:
    - ReadWriteMany
  nfs:
    server: EFS_DNS_NAME
    path: "/"

EFS_DNS_NAME: DNS name as shown in description of paddle-efs that we created. Looks similar to fs-2cbf7385.efs.us-west-2.amazonaws.com

Run following command to create a persistent volumn:

kubectl --kubeconfig=kubeconfig create -f pv.yaml

Next let’s create a PersistentVolumeClaim to claim the persistent volume.

Save following snippet as pvc.yaml.

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: efsvol
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 50Gi

Run following command to create a persistent volumn claim:

kubectl --kubeconfig=kubeconfig create -f pvc.yaml

Prepare Training Data

We will now launch a kubernetes job that downloads, saves and evenly splits training data into 3 shards on the persistent volumn that we just created.

save following snippet as paddle-data-job.yaml

apiVersion: batch/v1
kind: Job
metadata:
  name: paddle-data
spec:
  template:
    metadata:
      name: pi
    spec:
      containers:
      - name: paddle-data
        image: paddlepaddle/paddle-tutorial:k8s_data
        imagePullPolicy: Always
        volumeMounts:
        - mountPath: "/efs"
          name: efs
        env:
        - name: OUT_DIR
          value: /efs/paddle-cluster-job
        - name: SPLIT_COUNT
          value: "3"
      volumes:
        - name: efs
          persistentVolumeClaim:
            claimName: efsvol
      restartPolicy: Never

Run following command to launch the job:

kubectl --kubeconfig=kubeconfig create -f paddle-data-job.yaml

Job may take 7 min to finish, use following command to check job status. Do not proceed until SUCCESSFUL for paddle-data job is 1

$ kubectl --kubeconfig=kubeconfig get jobs
NAME          DESIRED   SUCCESSFUL   AGE
paddle-data   1         1            6m

Data preparation is done by docker image paddlepaddle/paddle-tutorial:k8s_data, see here for how to build this docker image and source code.

Start Training

Now we are ready to start paddle training job. Save following snippet as paddle-cluster-job.yaml

apiVersion: batch/v1
kind: Job
metadata:
  name: paddle-cluster-job
spec:
  parallelism: 3
  completions: 3
  template:
    metadata:
      name: paddle-cluster-job
    spec:
      volumes:
      - name: efs
        persistentVolumeClaim:
          claimName: efsvol
      containers:
      - name: trainer
        image: paddlepaddle/paddle-tutorial:k8s_train
        command: ["bin/bash",  "-c", "/root/start.sh"]
        env:
        - name: JOB_NAME
          value: paddle-cluster-job
        - name: JOB_PATH
          value: /home/jobpath
        - name: JOB_NAMESPACE
          value: default
        - name: TRAIN_CONFIG_DIR
          value: quick_start
        - name: CONF_PADDLE_NIC
          value: eth0
        - name: CONF_PADDLE_PORT
          value: "7164"
        - name: CONF_PADDLE_PORTS_NUM
          value: "2"
        - name: CONF_PADDLE_PORTS_NUM_SPARSE
          value: "2"
        - name: CONF_PADDLE_GRADIENT_NUM
          value: "3"
        - name: TRAINER_COUNT
          value: "3"
        volumeMounts:
        - mountPath: "/home/jobpath"
          name: efs
        ports:
        - name: jobport0
          hostPort: 7164
          containerPort: 7164
        - name: jobport1
          hostPort: 7165
          containerPort: 7165
        - name: jobport2
          hostPort: 7166
          containerPort: 7166
        - name: jobport3
          hostPort: 7167
          containerPort: 7167
      restartPolicy: Never

parallelism: 3, completions: 3 means this job will simultaneously start 3 PaddlePaddle pods, and this job will be finished when there are 3 finished pods.

env field represents container’s environment variables, we specify PaddlePaddle parameters by environment variables.

ports indicates that TCP port 7164 - 7167 are exposed for communication between pserver ans trainer. port starts continously from CONF_PADDLE_PORT (7164) to CONF_PADDLE_PORT + CONF_PADDLE_PORTS_NUM + CONF_PADDLE_PORTS_NUM_SPARSE - 1 (7167). We use multiple ports for dense and sparse paramter updates to improve latency.

Run following command to launch the job.

kubectl --kubeconfig=kubeconfig create -f paddle-claster-job.yaml

Inspect individual pods

$ kubectl --kubeconfig=kubeconfig get pods
NAME                       READY     STATUS    RESTARTS   AGE
paddle-cluster-job-cm469   1/1       Running   0          9m
paddle-cluster-job-fnt03   1/1       Running   0          9m
paddle-cluster-job-jx4xr   1/1       Running   0          9m

Inspect individual console output

kubectl --kubeconfig=kubeconfig log -f POD_NAME

POD_NAME: name of any pod (e.g., paddle-cluster-job-cm469).

Run kubectl --kubeconfig=kubeconfig describe job paddle-cluster-job to check training job status. It will complete in around 20 minutes.

The details for start pserver and trainer are hidden inside docker image paddlepaddle/paddle-tutorial:k8s_train, see here for how to build the docker image and source code.

Inspect Training Output

Training output (model snapshot and logs) will be saved in EFS. We can ssh into worker EC2 instance, mount EFS and check training output.

1. ssh Into Worker EC2 instance

chmod 400 key-name.pem
ssh -i key-name.pem core@INSTANCE_IP

INSTANCE_IP: public IP address of EC2 kubernetes worker node. Go to EC2 console and check public IP of any paddle-cluster-kube-aws-worker instance.

1. Mount EFS

mkdir efs
sudo mount -t nfs4 -o nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2 EFS_DNS_NAME:/ efs

EFS_DNS_NAME: DNS name as shown in description of paddle-efs that we created. Look similar to fs-2cbf7385.efs.us-west-2.amazonaws.com.

Now folder efs will have structure similar to:

-- paddle-cluster-job
    |-- ...
    |-- output
    |   |-- node_0
    |   |   |-- server.log
    |   |   `-- train.log
    |   |-- node_1
    |   |   |-- server.log
    |   |   `-- train.log
    |   |-- node_2
    |   |   |-- server.log
    |   |   `-- train.log
    |   |-- pass-00000
    |   |   |-- ___fc_layer_0__.w0
    |   |   |-- ___fc_layer_0__.wbias
    |   |   |-- done
    |   |   |-- path.txt
    |   |   `-- trainer_config.lr.py
    |   |-- pass-00001...

server.log contains log for pserver. train.log contains log for trainer. Model description and snapshot is stored in pass-0000*.

Kubernetes Cluster Tear Down

Delete EFS

Go to EFS Console and delete the EFS volumn that we created.

Delete security group

Go to Security Group Console and delete security group paddle-efs.

Delete S3 Bucket

Go to S3 Console and delete the S3 bucket that we created.

Destroy Cluster

kube-aws destroy

The command will return immediately, but it might take 5 min to tear down the whole cluster.

You can go to CludFormation Console to check destroy process.