130 lines
6.3 KiB
Markdown
130 lines
6.3 KiB
Markdown
---
|
|
title: Server
|
|
header-img: img/header_img/server.jpg
|
|
date: 2018-03-07 09:50:12
|
|
description: Spectrum Protect Server in a Docker Container
|
|
---
|
|
# Putting Spectrum Protect into a Container
|
|
(These instructions as based on Spectrum Protect 8.1.4. References to *SP* means Spectrum Protect.)
|
|
|
|
## Create your Dockerfile
|
|
As at the time of writing these instructions, Red Hat linux is not available in the Docker hub - but CentOS is a good clone. We'll use it
|
|
|
|
### Image preparation
|
|
```Dockerfile
|
|
FROM centos:7
|
|
```
|
|
|
|
Next we need to install some dependancies - these are documented in the Knowledge Center as a requirement for running SP on Linux
|
|
|
|
```Dockerfile
|
|
RUN yum -y install http://yum.leenooks.net/CentOS/7/base/redhat-release-7-6.el7.centos.12.2.x86_64.rpm \
|
|
libaio \
|
|
ksh \
|
|
compat-libstdc++-33 \
|
|
numactl && \
|
|
yum clean all && rm -rf /var/tmp/*
|
|
```
|
|
|
|
<small>**NOTE**: During the installation of SP, it tests to make sure it is running on RedHat linux by testing the existence of an RPM package `redhat-release`. The redhat-release installed on line 1 is a fake RPM package - it installs no files, but just emulates the existance of that required RPM package.</small>
|
|
|
|
### Spectrum Protect Installation
|
|
|
|
Now copy in our silent install configuration files
|
|
```Dockerfile
|
|
COPY install.xml install-fp.xml /tmp/
|
|
```
|
|
<small>**NOTE**: We only include the silent install configuration files here - not the installation media, otherwise the size of the resulting Docker image is too big. Current versions of `docker build` do provide the ability to "flatten" the resulting container, but those instructions are outside the scope of this tutorial.</small>
|
|
**INCLUDE LINKS TO install.xml files**
|
|
|
|
Next, is performing a silent installation of SP.
|
|
|
|
```Dockerfile
|
|
RUN mkdir -p /tmp/build/8.1.0 && cd /tmp/build/8.1.0 && \
|
|
curl -SL http://SITE_URL/docker/tsm/8.1.0 > tsm && \
|
|
chmod +x tsm && ./tsm && rm -f tsm && \
|
|
./install.sh -s -input /tmp/install.xml -acceptLicense && \
|
|
rm -rf /tmp/build/8.1.0 && \
|
|
mkdir -p /tmp/build/8.1.x && cd /tmp/build/8.1.x && \
|
|
curl -SL http://SITE_URL/docker/tsm/8.1.x > tsm && \
|
|
chmod +x tsm && ./tsm && rm -f tsm && \
|
|
./install.sh -s -input /tmp/install-fp.xml -acceptLicense && df && \
|
|
rm -rf /tmp/install* /tmp/build/8.1.x
|
|
```
|
|
|
|
**NOTE**: Some information on what is occuring here.
|
|
* This is an "new install" (lines 1-5) then followed by an "upgrade" (lines 6-12). The reason for the new install first, is that the Spectrum Protect license files and license libraries are not available in upgrades. So you'll need to install from your downloaded media from Passport Advantage, and then upgrade it to the latest release from Fix Central.
|
|
* To avoid the resulting Docker Image being too large, we download the installation media from a web server (Line 2) and then delete it after it has been expanded (line 3). We also do the same for up upgrade package (lines 7 & 8).
|
|
* Lines 4 and 9 are silent installation methods for install SP and applying updates.
|
|
* Lines 5 and 10 delete any installation files to reduce the size of the resulting Docker Image.
|
|
|
|
### Spectrum Protect Post-Installation
|
|
|
|
Now we set our user environment that will utlimately run SP
|
|
```Dockerfile
|
|
ENV USER=tsm USERDIR=/tsm USERID=201 GROUPID=201
|
|
```
|
|
<small>**NOTE**: You can set these according to your enterprise policy. `USERDIR` will ultimately need to be persistant storage using your favourite storage provisioning methodology. I generally host mount when starting the container using `-v /host/path/user:/tsm` and it works well. I have used some 3rd party persistent storage offerings, however, they often have not worked. While I havent explored in detail why not, I suspect it is because of Direct IO calls being made by DB2 and those 3rd party offerings not supporting those sytem calls.</small>
|
|
|
|
Now we create our user
|
|
|
|
```Dockerfile
|
|
RUN groupadd servers -g ${GROUPID} && useradd -d ${USERDIR} -u ${USERID} -g ${GROUPID} -s /bin/bash ${USER}
|
|
```
|
|
|
|
Copy some default Server configuration files in place
|
|
|
|
```Dockerfile
|
|
COPY dsmserv.opt tsmdbmgr.opt ${USERDIR}/
|
|
COPY dsm.sys /opt/tivoli/tsm/server/bin/dbbkapi/
|
|
RUN chmod a+r /opt/tivoli/tsm/server/bin/dbbkapi/dsm.sys
|
|
```
|
|
**INCLUDE LINKS TO files**
|
|
|
|
We'll now do some post installation setup, first create the DB2 instance for our user and change the default directory for the database to be the same as the instance directory for the server.
|
|
|
|
```Dockerfile
|
|
RUN /opt/tivoli/tsm/db2/instance/db2icrt -a server -s ese -u ${USER} ${USER} && \
|
|
mkdir -m 750 /database && \
|
|
chown ${USER}:servers /database /tsm/dsmserv.opt /tsm/tsmdbmgr.opt && \
|
|
su ${USER} -lc "db2 update dbm cfg using dftdbpath ${USERDIR} && db2set -i ${USER} DB2NOEXITLIST=ON"
|
|
```
|
|
<small>**NOTE**: Keep all these commands on one RUN line otherwise the `db2 update dbm` command will fail with an `SQL6031N` error.</small>
|
|
|
|
|
|
Setup sqllib/userprofile
|
|
|
|
```Dockerfile
|
|
RUN su ${USER} -lc "echo setenv LD_LIBRARY_PATH /opt/tivoli/tsm/server/bin/dbbkapi:/usr/local/ibm/gsk8_64/lib64:\\\$LD_LIBRARY_PATH >> sqllib/usercshrc && echo export LD_LIBRARY_PATH=/opt/tivoli/tsm/server/bin/dbbkapi:/usr/local/ibm/gsk8_64/lib64:\\\$LD_LIBRARY_PATH >> sqllib/userprofile && echo export DSMI_CONFIG=${USERDIR}/tsmdbmgr.opt >> sqllib/userprofile && echo export DSMI_DIR=/opt/tivoli/tsm/server/bin/dbbkapi >> sqllib/userprofile && echo export DSMI_LOG=${USERDIR} >> sqllib/userprofile"
|
|
```
|
|
|
|
### Final Docker Image Parameters
|
|
|
|
And our final Docker Image settings for when our container starts.
|
|
|
|
```Dockerfile
|
|
EXPOSE 1500 1543
|
|
|
|
VOLUME [ "${USERDIR}","/database","/data" ]
|
|
|
|
COPY admin.macro /tsm/
|
|
COPY init /sbin/
|
|
|
|
# Starting
|
|
ENTRYPOINT [ "/sbin/init" ]
|
|
CMD [ "start" ]
|
|
```
|
|
|
|
A complete Dockerfile is available here **TODO** if you need one as a starting point. Once you have your images loaded on a web server, the config files, you are reading to run `docker build -t ibm/spectrumprotect:8.1.x .`
|
|
|
|
If your final build is successful, you should see a Docker Image that is about 3GB.
|
|
|
|
```plain
|
|
REPOSITORY TAG IMAGE ID CREATED SIZE
|
|
ibm/spectrumprotect 8.1.1 14aba816e231 2 minutes ago 2.96GB
|
|
```
|
|
**NOTES**
|
|
* Make sure you have enough space in your `/var/lib/docker` directory - the build will use many GBs.
|
|
|
|
Now that your container is built, you'll want to start it a specific way, depending on whether you are starting a clean new instance of SP, or an existing instance. Those details are [here](here).
|