SAS administration command-line interface in a container: Part 1 Docker
In this post we will create a container image that contains the SAS administration command line interface. We will build a container image to show how this can be done and then run some Viya tasks using the container. Initially, the container will be run using Docker. A follow up post takes the container and run it in a Viya 4 kubernetes cluster to do some more advanced processing.
Why?
Having the sas-admin command-line interface, and other administration tools in a container has a number of benefits. We get all the benefits of containerization for our administration clients:
- standardized packaging: the container will include the sas-admin cli, all the plug-ins and any related software.
- better version control: we can have multiple versions of the cli and the plugins all running on the same system. We can tag different versions different ways so that it is clear what version is being used.
- consistency in runtime environment: When the cli is runs from the container the environment will always be the same. No need to worry about interactions with other software or missing pieces that are required.
- scalability: as we will see later when we start run on Kubernetes we can execute many container based cli processes sequentially or in parallel in a cluster.
A containerized cli could be used to automate:
- initialization of a new Viya environment
- export and import of content between Viya environments
- loading and unloading of data
- testing of functionality and performance.
I am sure you can think of many more. Let's see how we do it. Firstly, a really quick review of some docker terminology. Docker images are the basis of containers. An image typically contains a union of layered file systems stacked on top of each other. A container is a runtime instance of a docker image. A Dockerfile is used to build a docker image. In this post we will step through the process:
- Create a Dockerfile that defines our container image
- Build the container image from the contents of the DockerFile
- Run the container and perform some processing in Viya
Create a DockerFile
The docker file we will use to create our own custom Docker image for the sas-admin cli is shown below. This file contains all the commands you would normally execute manually in order to build a Docker image. When you build an image docker reads the instructions from a docker file. They key instructions in the file are:
The FROM instruction usually starts the dockerfile and defines the base image on which your new image is built. Most of the time you will start from an existing docker image and build on top of it. Here we start from the Centos:7 image.
The RUN instruction will execute commands in a new layer on top of the current image and commit the results. The first block of RUN commands layers the required software on top of the base image. Included in this we install pyviyatools from github.
The ADD and COPY commands are similar and are used to copy files/directories into a Docker image. The main difference is ADD allows the source to be a URL. The adds add the sas-admin executable the COPY includes a script that will run when the image is built to install all the available sas-admin plugins. You can see the script in a prior post on keeping the cli current. This sets the user that is used when running the container.
Select any image to see a larger version.
Mobile users: To view the images, select the "Full" version at the bottom of the page.
Build the container image
With the DockerFile defined use the build command, passing the filename to build the image. The -t tags the image with the name provided.
The first time the build is run it will take some time, subsequent builds will be quicker as docker caches the layers. As the build process runs the result of each step will be displayed (partial output below)
Using the sas-admin cli container image
Now we can use docker container run to run the sas-admin cli. Firstly, as a test lets just look at the plug-ins that are available. This will prove that our container works and can run a sas-admin cli command.
The sas-admin cli requires two prerequisites to run, a profile which defines what Viya system to access, and it requires that the user authenticate. You can create a profile and authenticate using the sas-admin cli. The process creates two files one containing the endpoint you want to connect to, and another containing an authentication token.
When running the container, instead of having to authenticate with every execution we will share the token and profile from the host into the container. We will use a docker volume to mount the profile (config.json) and the credentials file (credentials.json) from the host machine to the location that the cli expects them to be located in the container (the users home-directory). With that information made available we can use the container to run sas-admin cli commands. As an example this one list all the groups defined in the system.
The docker run command below uses the following parameters.
- -it runs in an interactive terminal
- -v mounts a directory or a file
- -e sets an environment variable in the container (the variable tells the CLI what profile to use)
- sasadmincli:v01 is the container image
In addition to single commands we can use the container to execute whole scripts that do more complex processing. For example, to execute a script that loads data to CAS and sets authorization on the loaded data the docker run is modified to share the script from, for an nfs mount, into the container.
At this point the image is running in Docker on my local machine. To make it available generally it needs to be pushed to a Docker registry. A Docker registry is a storage and content delivery system, holding named Docker images, available in different tagged versions. To push our sas-admincli image to the registry tag the image with a tag that includes the registry name and use the docker image push command.
Now to use the image you can use the docker pull command.
In this post we have looked at how to build and run a container that will perform sas-admin cli processing. In my next post I will take this approach a few steps further, the additional steps will really show the power of using an administration container as we start to use the functionality with Viya 2020 on a Kubernetes cluster.
Search for more content from our group: SAS Global Enablement & Learning.
