Containerized service deployments

The TinyMCE Enterprise server-side components can be deployed on Docker orchestration applications such as Kubernetes, Docker Swarm, or OpenShift. Tiny provides packages containing pre-configured Dockerfiles for building and deploying the TinyMCE Enterprise server-side components using Docker.

Outline

Containerized services for Self-hosted Enterprise deployments
Containerized services for individually licensed premium plugins

Containerized services for Self-hosted Enterprise deployments

The following sections assist with containerizing the TinyMCE services for users with licenses to the Self-hosted TinyMCE Enterprise bundles:

The Self-hosted Essential bundle.
The Self-hosted Professional bundle.
The Self-hosted Premium bundle.

Prerequisites

The Docker Engine is installed and running.
The user has Administrative or Root user access.
The user is either:
- Using a Linux, Unix or macOS operating system.
- Using Windows and has access to unix command line tools using Git for Windows, Cygwin, or the Windows Subsystem for Linux.

Download and extract the TinyMCE Self-hosted Bundle

Go to Tiny Account Downloads and download the TinyMCE self-hosted bundle .zip file.
Open a command line and navigate to the directory containing the downloaded .zip file:
- TinyMCE-Essential_latest.zip for Self-hosted Essential users.
- TinyMCE-Professional_latest.zip for Self-hosted Professional users.
- TinyMCE-Premium_latest.zip for Self-hosted Premium users.
Windows Users should open a Bash command line as the Administrator User.

Extract the contents of the .zip file, such as:

 unzip TinyMCE-Premium_latest.zip -d tinymce-selfhosted

The structure of the extracted files will be:

 tinymce-selfhosted/
 ├── tinymce/
 └── tinymce-services/
     ├── ephox-hyperlinking-docker-starter-kit.zip
     ├── ephox-hyperlinking.war
     ├── ephox-image-proxy-docker-starter-kit.zip
     ├── ephox-image-proxy.war
     ├── ephox-spelling-docker-starter-kit.zip
     ├── ephox-spelling.war
     └── version.txt

Navigate into the tinymce-services folder.

 cd tinymce-selfhosted/tinymce-services/

Proceed to setting up and deploying the containerized services:

For the Enhanced Media Embed and Link Checker service, see: Deploy the TinyMCE hyperlinking server-side component using Docker (self-hosted enterprise bundles).
For the Image Tools plugin service, see: Deploy the TinyMCE image proxy server-side component using Docker (self-hosted enterprise bundles).
For the Spell Checker Pro service, see: Deploy the TinyMCE spelling service server-side component using Docker (self-hosted enterprise bundles).

Deploy the TinyMCE hyperlinking server-side component using Docker (self-hosted enterprise bundles)

The TinyMCE hyperlinking server-side component can be deployed using Docker or a container orchestration application such as Kubernetes. Tiny provides a pre-configured package for creating a Hyperlinking Docker image.

Do not push this docker image to a publicly accessible container registry. Doing so will constitute a breach of the Tiny Self-Hosted Software License Agreement, including:

Procedure

The following procedure covers downloading, configuring, building and testing the TinyMCE Hyperlinking Docker image.

This procedure assumes that a TinyMCE self-hosted enterprise bundle has been extracted as described in Download and extract the TinyMCE Self-hosted Bundle.

Navigate into the tinymce-services folder.

 cd tinymce-selfhosted/tinymce-services/

Extract the contents of ephox-hyperlinking-docker-starter-kit.zip, such as:

 unzip ephox-hyperlinking-docker-starter-kit.zip -d hyperlinking-service-dockerfile

The structure of the extracted files will be:

 hyperlinking-service-dockerfile/
 ├── config
 │   └── ephox-hyperlinking-docker-env.conf
 ├── docker-entrypoint.sh
 ├── Dockerfile
 └── generate-jetty-start.sh

Copy ephox-hyperlinking.war into the directory containing the extracted files, such as:
```
 cp ephox-hyperlinking.war hyperlinking-service-dockerfile/
```
Navigate into the hyperlinking-service-dockerfile folder.
```
 cd hyperlinking-service-dockerfile
```
Set the permissions on the extracted files to executable.
```
 chmod +x *.sh
```
Optional: Edit the http configuration settings in config/ephox-hyperlinking-docker-env.conf. The configurable settings are in the http section of the file. For example:
```
 http {
   max-connections = 100
   max-connections-per-host = 10
   max-redirects = 10
   max-retries = 3
   request-timeout-seconds = 10
   trust-all-cert = false
   websphere = {
     use-ssl-config = true
   }
 }
```
For information on the http configuration setting, see: Configure server-side components - http.
Optional: Update the link-checking cache configuration, as described in Link Checker self-hosted quick setup.
Optional: Configure the Enhanced Media Embed Service, as described in Configure Enhanced Media Embed Server.
Optional: Configure the service to use a HTTP proxy by updating config/ephox-hyperlinking-docker-env.conf. See: Configure server-side components - proxy.
Create an origins.env file in the same directory as the Dockerfile, and specify the Hypertext Transfer Protocol (HTTP) and domain name of sites hosting the TinyMCE editor (allowed-origins). Up to 99 origins can be added without editing config/ephox-hyperlinking-docker-env.conf.

For example:
```
 ORIGIN0=example.net
 ORIGIN1=example
 ORIGIN2=http://example.org
```
For information on allowed-origins, see: Configure server-side components - allowed-origins.
As the root user or Administrator, build the TinyMCE Hyperlinking Docker image using the following command:
```
 docker build -t tinymce-hyperlinking-service .
```
As the root user or Administrator, deploy the service using the following command:
```
 docker run -d -p 8083:8080 --env-file origins.env tinymce-hyperlinking-service
```
Where:
- -p 8083:8080 maps the container port 8080 to local port 8083.
- --env-file origins.env adds the allowed origins to the container.
To verify that the Docker container is deployed and the hyperlinking service is running, execute:
```
curl http://localhost:8083/ephox-hyperlinking/
```
The response from the curl command should be:
```
Link checking and media embedding service is running.
```

The TinyMCE Hyperlinking Docker image can now be pushed to a private container registry for deployment on Kubernetes, Docker Swarm or OpenShift.

Deploy the TinyMCE image proxy server-side component using Docker (self-hosted enterprise bundles)

The TinyMCE image proxy server-side component can be deployed using Docker or a container orchestration application such as Kubernetes. Tiny provides a pre-configured package for creating a Image Proxy Docker image.

Do not push this docker image to a publicly accessible container registry. Doing so will constitute a breach of the Tiny Self-Hosted Software License Agreement, including:

Procedure

The following procedure covers downloading, configuring, building and testing the TinyMCE Image Proxy Docker image.

This procedure assumes that a TinyMCE self-hosted enterprise bundle has been extracted as described in Download and extract the TinyMCE Self-hosted Bundle.

Navigate into the tinymce-services folder.

 cd tinymce-selfhosted/tinymce-services/

Extract the contents of ephox-image-proxy-docker-starter-kit.zip, such as:

 unzip ephox-image-proxy-docker-starter-kit.zip -d image-proxy-service-dockerfile

Copy ephox-image-proxy.war into the directory containing the extracted files, such as:
```
 cp ephox-image-proxy.war image-proxy-service-dockerfile/
```
Navigate into the image-proxy-service-dockerfile folder.
```
 cd image-proxy-service-dockerfile
```
Set the permissions on the extracted files to executable.
```
 chmod +x *.sh
```
Optional: Edit the image-proxy configuration setting in config/ephox-image-proxy-docker-env.conf. The configurable setting is in the image-proxy section of the file. For example:
```
 image-proxy {
   image-size = 10000000 // 10MB in bytes
 }
```
For information on the image-proxy configuration setting, see: Configure server-side components - image-proxy.
Optional: Edit the http configuration settings in config/ephox-image-proxy-docker-env.conf. The configurable settings are in the http section of the file. For example:
```
 http {
   max-connections = 100
   max-connections-per-host = 10
   max-redirects = 10
   max-retries = 3
   request-timeout-seconds = 10
   trust-all-cert = false
   websphere = {
     use-ssl-config = true
   }
 }
```
For information on the http configuration setting, see: Configure server-side components - http.
Optional: Configure the service to use a HTTP proxy by updating config/ephox-image-proxy-docker-env.conf. See: Configure server-side components.
Create an origins.env file in the same directory as the Dockerfile, and specify the Hypertext Transfer Protocol (HTTP) and domain name of sites hosting the TinyMCE editor (allowed-origins). Up to 99 origins can be added without editing config/ephox-image-proxy-docker-env.conf.

For example:
```
 ORIGIN0=example.net
 ORIGIN1=example
 ORIGIN2=http://example.org
```
For information on allowed-origins, see: Configure server-side components - allowed-origins.
As the root user or Administrator, build the TinyMCE Image Proxy Docker image using the following command:
```
 docker build -t tinymce-image-proxy-service .
```
As the root user or Administrator, deploy the service using the following command:
```
 docker run -d -p 8081:8080 --env-file origins.env tinymce-image-proxy-service
```
Where:
- -p 8081:8080 maps the container port 8080 to local port 8081.
- --env-file origins.env adds the allowed origins to the container.
To verify that the Docker container is deployed and the image proxy is running, execute:
```
curl http://localhost:8081/ephox-image-proxy/
```
The response from the curl command should be:
```
Image proxy service is running.
```

The TinyMCE Image Proxy Docker image can now be pushed to a private container registry for deployment on Kubernetes, Docker Swarm or OpenShift.

Deploy the TinyMCE spelling service server-side component using Docker (self-hosted enterprise bundles)

The TinyMCE spelling service server-side component can be deployed using Docker or a container orchestration application such as Kubernetes. Tiny provides a pre-configured package for creating a Spelling Service Docker image.

Do not push this docker image to a publicly accessible container registry. Doing so will constitute a breach of the Tiny Self-Hosted Software License Agreement, including:

Procedure

The following procedure covers downloading, configuring, building and testing the TinyMCE Spelling Service Docker image.

This procedure assumes that a TinyMCE self-hosted enterprise bundle has been extracted as described in Download and extract the TinyMCE Self-hosted Bundle.

Navigate into the tinymce-services folder.
```
cd tinymce-selfhosted/tinymce-services/
```

Extract the contents of ephox-spelling-docker-starter-kit.zip, such as:

unzip ephox-spelling-docker-starter-kit.zip -d spelling-service-dockerfile

The structure of the extracted files will be:

spelling-service-dockerfile/
├── config
│   └── ephox-spelling-docker-env.conf
├── docker-entrypoint.sh
├── Dockerfile
└── generate-jetty-start.sh

Copy ephox-spelling.war into the directory containing the extracted files, such as:
```
cp ephox-spelling.war spelling-service-dockerfile/
```
Navigate into the spelling-service-dockerfile folder.
```
cd spelling-service-dockerfile
```
Set the permissions on the extracted files to executable.
```
chmod +x *.sh
```
Optional: Edit the http configuration settings in config/ephox-spelling-docker-env.conf. The configurable settings are in the http section of the file. For example:
```
http {
  max-connections = 100
  max-connections-per-host = 10
  max-redirects = 10
  max-retries = 3
  request-timeout-seconds = 10
  trust-all-cert = false
  websphere = {
    use-ssl-config = true
  }
}
```
For information on the http configuration setting, see: Configure server-side components - http.
Optional: Configure the service to use a HTTP proxy by updating config/ephox-spelling-docker-env.conf. See: Configure server-side components.
Optional: Add a custom dictionary, as described in Adding custom dictionaries.
Create an origins.env file in the same directory as the Dockerfile, and specify the Hypertext Transfer Protocol (HTTP) and domain name of sites hosting the TinyMCE editor (allowed-origins). Up to 99 origins can be added without editing config/ephox-spelling-docker-env.conf.

For example:
```
ORIGIN0=example.net
ORIGIN1=example
ORIGIN2=http://example.org
```
For information on allowed-origins, see: Configure server-side components - allowed-origins.
As the root user or Administrator, build the TinyMCE Spelling Service Docker image using the following command:
```
docker build -t tinymce-spelling-service .
```
As the root user or Administrator, deploy the service using the following command:
```
docker run -d -p 8082:8080 --env-file origins.env tinymce-spelling-service
```
Where:
- -p 8082:8080 maps the container port 8080 to local port 8082.
- --env-file origins.env adds the allowed origins to the container.
To verify that the Docker container is deployed and the spelling service is running, execute:
```
curl http://localhost:8082/ephox-spelling/
```
The response from the curl command should be:
```
Spelling service is running.
```

The TinyMCE Spelling Service Docker image can now be pushed to a private container registry for deployment on Kubernetes, Docker Swarm or OpenShift.

Containerized services for individually licensed premium plugins

The following sections assist with containerizing the TinyMCE services for users with licenses to self-hosted versions of:

Select from the following:

For the Tiny Enhanced Media Embed and Tiny Link Checker service, see: Deploy the TinyMCE hyperlinking server-side component using Docker (individually licensed).
For the Tiny Spell Checker Pro service, see: Deploy the TinyMCE spelling service server-side component using Docker (individually licensed).

Deploy the TinyMCE hyperlinking server-side component using Docker (individually licensed)

Do not push this docker image to a publicly accessible container registry. Doing so will constitute a breach of the Tiny Self-Hosted Software License Agreement, including:

Prerequisites

The Docker Engine is installed and running.
The user has Administrative or Root user access.
The user is either:
- Using a Linux, Unix or macOS operating system.
- Using Windows and has access to unix command line tools using Git for Windows, Cygwin, or the Windows Subsystem for Linux.

Procedure

The following procedure covers downloading, configuring, building and testing the TinyMCE Hyperlinking Docker image.

Go to Tiny Account > My Downloads and download either:
- Tiny Enhanced Media Embed, or
- Tiny Link Checker.
  1. Open a command line and navigate to the directory containing ephox-hyperlinking_<version>.zip. Windows Users should open a Bash command line as the Administrator User.
  2. Extract the contents of ephox-hyperlinking_<version>.zip, such as:
    
    unzip ephox-hyperlinking_<version>.zip -d tinymce-hyperlinking-service
  3. Navigate into the extracted folder.
    
    cd tinymce-hyperlinking-service
  4. Extract the contents of ephox-hyperlinking-docker-starter-kit.zip, such as:
    
    unzip ephox-hyperlinking-docker-starter-kit.zip
    
    The structure of the current directory (tinymce-hyperlinking-service/) will be:
    
    tinymce-hyperlinking-service/ ├── config │ └── ephox-hyperlinking-docker-env.conf ├── docker-entrypoint.sh ├── Dockerfile ├── ephox-hyperlinking-docker-starter-kit.zip ├── ephox-hyperlinking.war ├── generate-jetty-start.sh ├── license.txt ├── readme.txt └── version.txt
  5. Set the permissions on the extracted files to executable.
    
    chmod +x *.sh
  6. Optional: Edit the http configuration settings in config/ephox-hyperlinking-docker-env.conf. The configurable settings are in the http section of the file. For example:
    
    http { max-connections = 100 max-connections-per-host = 10 max-redirects = 10 max-retries = 3 request-timeout-seconds = 10 trust-all-cert = false websphere = { use-ssl-config = true } }
    
    For information on the http configuration setting, see: Configure server-side components - http.
  7. Optional: Update the link-checking cache configuration, as described in Link Checker self-hosted quick setup.
  8. Optional: Configure the Enhanced Media Embed Service, as described in Configure Enhanced Media Embed Server.
  9. Optional: Configure the service to use a HTTP proxy by updating config/ephox-hyperlinking-docker-env.conf. See: Configure server-side components - proxy.
  10. Create an origins.env file in the same directory as the Dockerfile, and specify the Hypertext Transfer Protocol (HTTP) and domain name of sites hosting the TinyMCE editor (allowed-origins). Up to 99 origins can be added without editing config/ephox-hyperlinking-docker-env.conf.
    
    For example:
    
    ORIGIN0=example.net ORIGIN1=example ORIGIN2=http://example.org
    
    For information on allowed-origins, see: Configure server-side components - allowed-origins.
  11. As the root user or Administrator, build the TinyMCE Hyperlinking Docker image using the following command:
    
    docker build -t tinymce-hyperlinking-service .
  12. As the root user or Administrator, deploy the service using the following command:
    
    docker run -d -p 8083:8080 --env-file origins.env tinymce-hyperlinking-service
    
    Where:
    
    -p 8083:8080 maps the container port 8080 to local port 8083.
    
    --env-file origins.env adds the allowed origins to the container.
  13. To verify that the Docker container is deployed and the hyperlinking service is running, execute:
    
    curl http://localhost:8083/ephox-hyperlinking/
    
    The response from the curl command should be:
    
    Link checking and media embedding service is running.

The TinyMCE Hyperlinking Docker image can now be pushed to a private container registry for deployment on Kubernetes, Docker Swarm or OpenShift.

Deploy the TinyMCE spelling service server-side component using Docker (individually licensed)

Do not push this docker image to a publicly accessible container registry. Doing so will constitute a breach of the Tiny Self-Hosted Software License Agreement, including:

Prerequisites

The Docker Engine is installed and running.
The user has Administrative or Root user access.
The user is either:
- Using a Linux, Unix or macOS operating system.
- Using Windows and has access to unix command line tools using Git for Windows, Cygwin, or the Windows Subsystem for Linux.

Procedure

The following procedure covers downloading, configuring, building and testing the TinyMCE Spelling Service Docker image.

Go to link:https://www.tiny.cloud/my-account Tiny Account[My Downloads] and download Tiny Spell Checker Pro.
Open a command line and navigate to the directory containing ephox-spelling_<version>.zip. Windows Users should open a Bash command line as the Administrator User.

Extract the contents of ephox-spelling_<version>.zip, such as:

unzip ephox-spelling_<version>.zip -d tinymce-spelling-service

Navigate into the extracted folder.
```
cd tinymce-spelling-service
```

Extract the contents of ephox-spelling-docker-starter-kit.zip, such as:

unzip ephox-spelling-docker-starter-kit.zip

The structure of the current directory (tinymce-spelling-service/) will be:

tinymce-spelling-service/
├── config
│   └── ephox-spelling-docker-env.conf
├── docker-entrypoint.sh
├── Dockerfile
├── ephox-spelling-docker-starter-kit.zip
├── ephox-spelling.war
├── generate-jetty-start.sh
├── license.txt
├── readme.txt
└── version.txt

Set the permissions on the extracted files to executable.
```
chmod +x *.sh
```
Optional: Edit the http configuration settings in config/ephox-spelling-docker-env.conf. The configurable settings are in the http section of the file. For example:
```
http {
  max-connections = 100
  max-connections-per-host = 10
  max-redirects = 10
  max-retries = 3
  request-timeout-seconds = 10
  trust-all-cert = false
  websphere = {
    use-ssl-config = true
  }
}
```
For information on the http configuration setting, see: Configure server-side components - http.
Optional: Configure the service to use a HTTP proxy by updating config/ephox-spelling-docker-env.conf. See: Configure server-side components.
Optional: Add a custom dictionary, as described in Adding custom dictionaries.
Create an origins.env file in the same directory as the Dockerfile, and specify the Hypertext Transfer Protocol (HTTP) and domain name of sites hosting the TinyMCE editor (allowed-origins). Up to 99 origins can be added without editing config/ephox-spelling-docker-env.conf.

For example:
```
ORIGIN0=example.net
ORIGIN1=example
ORIGIN2=http://example.org
```
For information on allowed-origins, see: Configure server-side components - allowed-origins.
As the root user or Administrator, build the TinyMCE Spelling Service Docker image using the following command:
```
docker build -t tinymce-spelling-service .
```
As the root user or Administrator, deploy the service using the following command:
```
docker run -d -p 8082:8080 --env-file origins.env tinymce-spelling-service
```
Where:
- -p 8082:8080 maps the container port 8080 to local port 8082.
- --env-file origins.env adds the allowed origins to the container.
To verify that the Docker container is deployed and the spelling service is running, execute:
```
curl http://localhost:8082/ephox-spelling/
```
The response from the curl command should be:
```
Spelling service is running.
```

The TinyMCE Spelling Service Docker image can now be pushed to a private container registry for deployment on Kubernetes, Docker Swarm or OpenShift.