{"id":7956,"date":"2024-05-21T14:50:07","date_gmt":"2024-05-21T12:50:07","guid":{"rendered":"https:\/\/www.credativ.de\/?p=7956"},"modified":"2025-11-24T18:29:17","modified_gmt":"2025-11-24T17:29:17","slug":"apache-guacamole-do-you-prefer-salsa-or-guacamole","status":"publish","type":"post","link":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/","title":{"rendered":"Apache Guacamole – Do you prefer Salsa or Guacamole?"},"content":{"rendered":"

\"\"<\/p>\n

If you had the choice, would you rather take Salsa or Guacamole? Let me explain, why you should choose Guacamole over Salsa.<\/p>\n

In this blog article, we want to take a look at one of the smaller Apache projects out there called Apache Guacamole<\/a>. Apache Guacamole allows administrators to run a web based client tool for accessing remote applications and servers. This can include remote desktop systems, applications or terminal sessions. Users can simply access them by using their web browsers. No special client or other tools are required. From there, they can login and access all pre-configured remote connections that have been specified by an administrator.<\/p>\n

Thereby, Guacamole supports a wide variety of protocols like VNC, RDP, and SSH. This way, users can basically access anything from remote terminal sessions to full fledged Graphical User Interfaces provided by operation systems like Debian, Ubuntu, Windows and many more.<\/p>\n

Convert every window application to a web application<\/h2>\n

If we spin this idea further, technically every window application that isn’t designed to run as an web application can be transformed to a web application by using Apache Guacamole. We helped a customer to bring its legacy application to Kubernetes, so that other users could use their web browsers to run it. Sure, implementing the application from ground up, so that it follows the Cloud Native principles, is the preferred solution. As always though, efforts, experience and costs may exceed the available time and budget and in that cases, Apache Guacamole can provide a relatively easy way for realizing such projects.<\/p>\n

In this blog article, I want to show you, how easy it is to run a legacy window application as a web app on Kubernetes. For this, we will use a Kubernetes cluster created by kind<\/code> and create a Kubernetes Deployment to make\u00a0kate<\/code>\u00a0– a KDE based text editor – our own web application. It’s just an example, so there might be better application to transform but this one should be fine to show you the concepts behind Apache Guacamole.<\/p>\n

So, without further ado, let’s create our kate<\/code>\u00a0web application.<\/p>\n

Preparation of Kubernetes<\/h2>\n

Before we can start, we must make sure that we have a Kubernetes cluster, that we can test on. If you already have a cluster, simply skip this section. If not, let’s spin one up by using\u00a0kind<\/code>.<\/p>\n

kind<\/code> is a lightweight implementation of Kubernetes that can be run on every machine. It’s written in Go and can be installed like this:<\/p>\n

# For AMD64 \/ x86_64<\/span>\r\n[<\/span> $(uname<\/span> -m<\/span>)<\/span> =<\/span> x86_64 ]<\/span> &&<\/span> curl<\/span> -Lo<\/span> .\/kind https:\/\/kind.sigs.k8s.io\/dl\/v0.22.0\/kind-linux-amd64\r\n# For ARM64<\/span>\r\n[<\/span> $(uname<\/span> -m<\/span>)<\/span> =<\/span> aarch64 ]<\/span> &&<\/span> curl<\/span> -Lo<\/span> .\/kind https:\/\/kind.sigs.k8s.io\/dl\/v0.22.0\/kind-linux-arm64\r\nchmod<\/span> +x .\/kind\r\nsudo<\/span> mv<\/span> .\/kind \/usr\/local\/bin\/kind\r\n<\/code><\/pre>\n
Next, we need to install some dependencies for our cluster. This includes for example docker<\/code> and kubectl<\/code>.<\/p>\n
$ sudo<\/span> apt<\/span> install<\/span> docker.io kubernetes-client\r\n<\/code><\/pre>\n
By creating our Kubernetes Cluster with kind<\/code>, we need docker<\/code> because the Kubernetes cluster is running within Docker containers on your host machine. Installing kubectl<\/code> allows us to access the Kubernetes after creating it.<\/p>\n
Once we installed those packages, we can start to create our cluster now. First, we must define a cluster configuration. It defines which ports are accessible from our host machine, so that we can access our Guacamole application. Remember, the cluster itself is operated within Docker containers, so we must ensure that we can access it from our machine. For this, we define the following configuration which we save in a file called cluster.yaml<\/code>:<\/p>\n
kind<\/span>:<\/span> Cluster\r\napiVersion<\/span>:<\/span> kind.x-<\/span>k8s.io\/v1alpha4\r\nnodes<\/span>:<\/span>\r\n-<\/span> role<\/span>:<\/span> control-<\/span>plane\r\n  extraPortMappings<\/span>:<\/span>\r\n  -<\/span> containerPort<\/span>:<\/span> 30000<\/span>\r\n    hostPort<\/span>:<\/span> 30000<\/span>\r\n    listenAddress<\/span>:<\/span> \"127.0.0.1\"<\/span>\r\n    protocol<\/span>:<\/span> TCP\r\n<\/code><\/pre>\n
Hereby, we basically map the container’s port 30000 to our local machine’s port 30000, so that we can easily access it later on. Keep this in mind because it will be the port that we will use with our web browser to access our kate<\/code> instance.<\/p>\n
As soon as you saved the configuration to cluster.yaml<\/code>, we can now start to create our cluster:<\/p>\n
$ sudo<\/span> kind create cluster --name<\/span> guacamole --config<\/span> cluster.yaml\r\nCreating cluster \"guacamole\"<\/span> ..<\/span>.\r\n \u2713 Ensuring node<\/span> image (<\/span>kindest\/node:v1.29.2)<\/span> \ud83d\uddbc\r\n \u2713 Preparing nodes \ud83d\udce6\r\n \u2713 Writing configuration \ud83d\udcdc\r\n \u2713 Starting control-plane \ud83d\udd79\ufe0f\r\n \u2713 Installing CNI \ud83d\udd0c\r\n \u2713 Installing StorageClass \ud83d\udcbe\r\nSet kubectl context to \"kind-guacamole\"<\/span>\r\nYou can now use your cluster with:\r\n\r\nkubectl cluster-info --context<\/span> kind-guacamole\r\n\r\nHave a question, bug, or feature request? Let us know!<\/span> https:\/\/kind.sigs.k8s.io\/#community \ud83d\ude42<\/span>\r\n<\/code><\/pre>\n
Since we don’t want to run everything in root context, let’s export the\u00a0kubeconfig<\/code>, so that we can use it with\u00a0kubectl<\/code> by using our unpriviledged user:<\/p>\n
$ sudo<\/span> kind export<\/span> kubeconfig \\<\/span>\r\n    --name<\/span> guacamole \\<\/span>\r\n    --kubeconfig<\/span> $PWD<\/span>\/config\r\n\r\n$ export<\/span> KUBECONFIG<\/span>=<\/span>$PWD<\/span>\/config\r\n$ sudo<\/span> chown<\/span> $(logname<\/span>)<\/span>:<\/span> $KUBECONFIG<\/span>\r\n<\/code><\/pre>\n
By doing so, we are ready and can access our Kubernetes cluster using kubectl<\/code> now. This is our baseline to start migrating our application.<\/p>\n
Creation of the Guacamole Deployment<\/h2>\n
In order to run our application on Kubernetes, we need some sort of workload resource. Typically, you could create a Pod, Deployment, Statefulset or Daemonset to run workloads on a cluster.<\/p>\n
Let’s create the Kubernetes Deployment for our own application. The example shown below shows the deployment’s general structure. Each container definition will have their dedicated examples afterwards to explain them in more detail.<\/p>\n
apiVersion<\/span>:<\/span> apps\/v1\r\nkind<\/span>:<\/span> Deployment\r\nmetadata<\/span>:<\/span>\r\n  labels<\/span>:<\/span>\r\n    app<\/span>:<\/span> web-<\/span>based-<\/span>kate\r\n  name<\/span>:<\/span> web-<\/span>based-<\/span>kate\r\nspec<\/span>:<\/span>\r\n  replicas<\/span>:<\/span> 1<\/span>\r\n  selector<\/span>:<\/span>\r\n    matchLabels<\/span>:<\/span>\r\n      app<\/span>:<\/span> web-<\/span>based-<\/span>kate\r\n  template<\/span>:<\/span>\r\n    metadata<\/span>:<\/span>\r\n      labels<\/span>:<\/span>\r\n        app<\/span>:<\/span> web-<\/span>based-<\/span>kate\r\n    spec<\/span>:<\/span>\r\n      containers<\/span>:<\/span>\r\n      # The guacamole server component that each<\/span>\r\n      # user will connect to via their browser<\/span>\r\n      -<\/span> name<\/span>:<\/span> guacamole-<\/span>server\r\n        image<\/span>:<\/span> docker.io\/guacamole\/guacamole:<\/span>1.5.4\r\n        ...<\/span>\r\n      # The daemon that opens the connection to the<\/span>\r\n      # remote entity<\/span>\r\n      -<\/span> name<\/span>:<\/span> guacamole-<\/span>guacd\r\n        image<\/span>:<\/span> docker.io\/guacamole\/guacd:<\/span>1.5.4\r\n        ...<\/span>\r\n      # Our own self written application that we<\/span>\r\n      # want to make accessible via the web.<\/span>\r\n      -<\/span> name<\/span>:<\/span> web-<\/span>based-<\/span>kate\r\n        image<\/span>:<\/span> registry.example.com\/own-<\/span>app\/web-<\/span>based-<\/span>kate:<\/span>0.0.1\r\n        ...<\/span>\r\n      volumes<\/span>:<\/span>\r\n        -<\/span> name<\/span>:<\/span> guacamole-<\/span>config\r\n          secret<\/span>:<\/span>\r\n            secretName<\/span>:<\/span> guacamole-<\/span>config\r\n        -<\/span> name<\/span>:<\/span> guacamole-<\/span>server\r\n          emptyDir<\/span>:<\/span> {<\/span>}<\/span>\r\n        -<\/span> name<\/span>:<\/span> web-<\/span>based-<\/span>kate-<\/span>home\r\n          emptyDir<\/span>:<\/span> {<\/span>}<\/span>\r\n        -<\/span> name<\/span>:<\/span> web-<\/span>based-<\/span>kate-<\/span>tmp\r\n          emptyDir<\/span>:<\/span> {<\/span>}<\/span>\r\n<\/code><\/pre>\n
As you can see, we need three containers and some volumes for our application. The first two containers are dedicated to Apache Guacamole itself. First, it’s the server component which is the external endpoint for clients to access our web application. It serves the web server as well as the user management and configuration to run Apache Guacamole.<\/p>\n
Next to this, there is the guacd<\/code> daemon. This is the core component of Guacamole which creates the remote connections to the application based on the configuration done to the server. This daemon forwards the remote connection to the clients by making it accessible to the Guacamole server which then forwards the connection to the end user.<\/p>\n
Finally, we have our own application. It will offer a connection endpoint to the guacd<\/code> daemon using one of Guacamole’s supported protocols and provide the Graphical User Interface (GUI).<\/p>\n
Guacamole Server<\/h4>\n
Now, let’s deep dive into each container specification. We are starting with the Guacamole server instance. This one handles the session and user management and contains the configuration which defines what remote connections are available and what are not.<\/p>\n
-<\/span> name<\/span>:<\/span> guacamole-<\/span>server\r\n  image<\/span>:<\/span> docker.io\/guacamole\/guacamole:<\/span>1.5.4\r\n  env<\/span>:<\/span>\r\n    -<\/span> name<\/span>:<\/span> GUACD_HOSTNAME\r\n      value<\/span>:<\/span> \"localhost\"<\/span>\r\n    -<\/span> name<\/span>:<\/span> GUACD_PORT\r\n      value<\/span>:<\/span> \"4822\"<\/span>\r\n    -<\/span> name<\/span>:<\/span> GUACAMOLE_HOME\r\n      value<\/span>:<\/span> \"\/data\/guacamole\/settings\"<\/span>\r\n    -<\/span> name<\/span>:<\/span> HOME\r\n      value<\/span>:<\/span> \"\/data\/guacamole\"<\/span>\r\n    -<\/span> name<\/span>:<\/span> WEBAPP_CONTEXT\r\n      value<\/span>:<\/span> ROOT\r\n  volumeMounts<\/span>:<\/span>\r\n    -<\/span> name<\/span>:<\/span> guacamole-<\/span>config\r\n      mountPath<\/span>:<\/span> \/data\/guacamole\/settings\r\n    -<\/span> name<\/span>:<\/span> guacamole-<\/span>server\r\n      mountPath<\/span>:<\/span> \/data\/guacamole\r\n  ports<\/span>:<\/span>\r\n    -<\/span> name<\/span>:<\/span> http\r\n      containerPort<\/span>:<\/span> 8080<\/span>\r\n  securityContext<\/span>:<\/span>\r\n    allowPrivilegeEscalation<\/span>:<\/span> false<\/span>\r\n    privileged<\/span>:<\/span> false<\/span>\r\n    readOnlyRootFilesystem<\/span>:<\/span> true<\/span>\r\n    capabilities<\/span>:<\/span>\r\n      drop<\/span>:<\/span> [<\/span>\"all\"<\/span>]<\/span>\r\n  resources<\/span>:<\/span>\r\n    limits<\/span>:<\/span>\r\n      cpu<\/span>:<\/span> \"250m\"<\/span>\r\n      memory<\/span>:<\/span> \"256Mi\"<\/span>\r\n    requests<\/span>:<\/span>\r\n      cpu<\/span>:<\/span> \"250m\"<\/span>\r\n      memory<\/span>:<\/span> \"256Mi\"<\/span>\r\n<\/code><\/pre>\n
Since it needs to connect to the guacd<\/code> daemon, we have to provide the connection information for guacd<\/code> by passing them into the container using environment variables like GUACD_HOSTNAME<\/code> or GUACD_PORT<\/code>. In addition, Guacamole would usually be accessible via http:\/\/<your domain>\/guacamole<\/code>.<\/p>\n
This behavior however can be adjusted by modifying the WEBAPP_CONTEXT<\/code> environment variable. In our case for example, we don’t want a user to type in \/guacamole<\/code> to access it but simply using it like this http:\/\/<your domain>\/<\/code><\/p>\n
Guacamole Guacd<\/h4>\n
Then, there is the guacd<\/code> daemon.<\/p>\n
-<\/span> name<\/span>:<\/span> guacamole-<\/span>guacd\r\n  image<\/span>:<\/span> docker.io\/guacamole\/guacd:<\/span>1.5.4\r\n  args<\/span>:<\/span>\r\n    -<\/span> \/bin\/sh\r\n    -<\/span> -<\/span>c\r\n    -<\/span> \/opt\/guacamole\/sbin\/guacd -<\/span>b 127.0.0.1 -<\/span>L $GUACD_LOG_LEVEL -<\/span>f\r\n  securityContext<\/span>:<\/span>\r\n    allowPrivilegeEscalation<\/span>:<\/span> true<\/span>\r\n    privileged<\/span>:<\/span> false<\/span>\r\n    readOnlyRootFileSystem<\/span>:<\/span> true<\/span>\r\n    capabilities<\/span>:<\/span>\r\n      drop<\/span>:<\/span> [<\/span>\"all\"<\/span>]<\/span>\r\n  resources<\/span>:<\/span>\r\n    limits<\/span>:<\/span>\r\n      cpu<\/span>:<\/span> \"250m\"<\/span>\r\n      memory<\/span>:<\/span> \"512Mi\"<\/span>\r\n    requests<\/span>:<\/span>\r\n      cpu<\/span>:<\/span> \"250m\"<\/span>\r\n      memory<\/span>:<\/span> \"512Mi\"<\/span>\r\n<\/code><\/pre>\n
It’s worth mentioning that you should modify the arguments used to start the guacd<\/code> container. In the example above, we want guacd<\/code> to only listen to localhost for security reasons. All containers within the same pod share the same network namespace. As a a result, they can access each other via localhost. This said, there is no need to make this service accessible to over services running outside of this pod, so we can limit it to localhost only. To achieve this, you would need to set the -b 127.0.0.1<\/code> parameter which sets the corresponding listen address. Since you need to overwrite the whole command, don’t forget to also specify the -L<\/code> and -f<\/code> parameter. The first parameter sets the log level and the second one set the process in the foreground.<\/p>\n
Web Based Kate<\/h4>\n
To finish everything off, we have the\u00a0kate<\/code>\u00a0application which we want to transform to a web application.<\/p>\n
-<\/span> name<\/span>:<\/span> web-<\/span>based-<\/span>kate\r\n  image<\/span>:<\/span> registry.example.com\/own-<\/span>app\/web-<\/span>based-<\/span>kate:<\/span>0.0.1\r\n  env<\/span>:<\/span>\r\n    -<\/span> name<\/span>:<\/span> VNC_SERVER_PORT\r\n      value<\/span>:<\/span> \"5900\"<\/span>\r\n    -<\/span> name<\/span>:<\/span> VNC_RESOLUTION_WIDTH\r\n      value<\/span>:<\/span> \"1280\"<\/span>\r\n    -<\/span> name<\/span>:<\/span> VNC_RESOLUTION_HEIGHT\r\n      value<\/span>:<\/span> \"720\"<\/span>\r\n  securityContext<\/span>:<\/span>\r\n    allowPrivilegeEscalation<\/span>:<\/span> true<\/span>\r\n    privileged<\/span>:<\/span> false<\/span>\r\n    readOnlyRootFileSystem<\/span>:<\/span> true<\/span>\r\n    capabilities<\/span>:<\/span>\r\n      drop<\/span>:<\/span> [<\/span>\"all\"<\/span>]<\/span>\r\n  volumeMounts<\/span>:<\/span>\r\n    -<\/span> name<\/span>:<\/span> web-<\/span>based-<\/span>kate-<\/span>home\r\n      mountPath<\/span>:<\/span> \/home\/kate\r\n    -<\/span> name<\/span>:<\/span> web-<\/span>based-<\/span>kate-<\/span>tmp\r\n      mountPath<\/span>:<\/span> \/tmp\r\n<\/code><\/pre>\n
Configuration of our Guacamole setup<\/h2>\n
After having the deployment in place, we need to prepare the configuration for our Guacamole setup. In order to know, what users exist and which connections should be offered, we need to provide a mapping configuration to Guacamole.<\/p>\n
In this example, a simple user mapping is shown for demonstration purposes. It uses a static mapping defined in a XML file that is handed over to the Guacamole server. Typically, you would use other authentication methods instead like a database or LDAP.<\/p>\n
This said however, let’s continue with our static one. For this, we simply define a Kubernetes Secret which is mounted into the Guacamole server. Hereby, it defines two configuration files. One is the so called\u00a0guacamole.properties<\/code>. This is Guacamole’s main configuration file. Next to this, we also define the user-mapping.xml<\/code>\u00a0which contains all available users and their connections.<\/p>\n
apiVersion<\/span>:<\/span> v1\r\nkind<\/span>:<\/span> Secret\r\nmetadata<\/span>:<\/span>\r\n  name<\/span>:<\/span> guacamole-<\/span>config\r\nstringData<\/span>:<\/span>\r\n  guacamole.properties<\/span>:<\/span> |<\/span>\r\n    enable-environment-properties: true<\/span>\r\n  user-mapping.xml<\/span>:<\/span> |<\/span>\r\n    <user-mapping>\r\n      <authorize username=\"admin\" password=\"PASSWORD\" encoding=\"sha256\">\r\n        <connection name=\"web-based-kate\">\r\n          <protocol>vnc<\/protocol>\r\n          <param name=\"hostname\">localhost<\/param>\r\n          <param name=\"port\">5900<\/param>\r\n        <\/connection>\r\n      <\/authorize>\r\n    <\/user-mapping><\/span>\r\n<\/code><\/pre>\n
As you can see, we only defined on specific user called\u00a0admin<\/code>\u00a0which can use a connection called\u00a0web-based-kate<\/code>. In order to access the\u00a0kate<\/code> instance, Guacamole would use VNC as the configured protocol. To make this happen, our web application must offer a VNC Server port on the other side, so that the guacd<\/code> daemon can then access it to forward the remote session to clients. Keep in mind that you need to replace the string PASSWORD<\/code> to a proper sha256 sum which contains the password. The sha256 sum could look like this for example:<\/p>\n
$ echo<\/span> -n<\/span> \"test\"<\/span> |<\/span> sha256sum\r\n9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08  -\r\n<\/code><\/pre>\n
Next, the hostname parameter is referencing the corresponding VNC server of our kate<\/code> container. Since we are starting our container alongside with our Guacamole containers within the same pod, the Guacamole Server as well as the guacd<\/code>\u00a0daemon can access this application via\u00a0localhost<\/code>. There is no need to set up a Kubernetes Service in front of it since only guacd<\/code>\u00a0will access the VNC server and forward the remote session via HTTP to clients accessing Guacamole via their web browsers. Finally, we also need to specify the VNC server port which is typically\u00a05900<\/code>\u00a0but this could be adjusted if needed.<\/p>\n
The corresponding\u00a0guacamole.properties<\/code>\u00a0is quite short. By enabling the\u00a0enabling-environment-properties<\/code>\u00a0configuration parameter, we make sure that every Guacamole configuration parameter can also be set via environment variables. This way, we don’t need to modify this configuration file each and every time when we want to adjust the configuration but we only need to provide updated environment variables to the Guacamole server container.<\/p>\n
Make Guacamole accessible<\/h2>\n
Last but not least, we must make the Guacamole server accessible for clients. Although each provided service can access each other via localhost, the same does not apply to clients trying to access Guacamole. Therefore, we must make Guacamole’s server port 8080 available to the outside world. This can be achieved by creating a Kubernetes Service of type NodePort<\/code>. This service is forwarding each request from a local node port to the corresponding container that is offering the configured target port. In our case, this would be the Guacamole server container which is offering port 8080.<\/p>\n
apiVersion<\/span>:<\/span> v1\r\nkind<\/span>:<\/span> Service\r\nmetadata<\/span>:<\/span>\r\n  name<\/span>:<\/span> web-<\/span>based-<\/span>kate\r\nspec<\/span>:<\/span>\r\n  type: NodePort\r\n  selector<\/span>:<\/span>\r\n    app<\/span>:<\/span> web-<\/span>based-<\/span>kate\r\n  ports<\/span>:<\/span>\r\n    -<\/span> name<\/span>:<\/span> http\r\n      protocol<\/span>:<\/span> TCP\r\n      port<\/span>:<\/span> 8080<\/span>\r\n      targetPort<\/span>:<\/span> 8080\r\n      nodePort: 30000<\/span>\r\n<\/code><\/pre>\n
This specific port is then mapped to the Node’s 30000 port for which we also configured the kind<\/code> cluster in such a way that it forwards its node port 30000 to the host system’s port 30000. This port is the one that we would need to use to access Guacamole with our web browsers.<\/p>\n
Prepartion of the Application container<\/h2>\n
Before we can start to deploy our application, we need to prepare our\u00a0kate<\/code> container. For this, we simply create a Debian container that is running kate<\/code>. Keep in mind that you would typically use lightweight base images like\u00a0alpine<\/code> to run applications like this. For this demonstration however, we use the Debian images since it is easier to spin it up but in general you only need a small friction of the functionality that is provided by this base image. Moreover – from an security point of view – you want to keep your images small to minimize the attack surface and make sure it is easier to maintain. For now however, we will continue with the Debian image.<\/p>\n
In the example below, you can see a Dockerfile for the\u00a0kate<\/code> container.<\/p>\n
FROM<\/span> debian:12<\/span>\r\n\r\n# Install all required packages<\/span>\r\nRUN<\/span> apt update && \\<\/span>\r\n    apt install -y x11vnc xvfb kate<\/span>\r\n\r\n# Add user for kate<\/span>\r\nRUN<\/span> adduser kate --system --home \/home\/kate -uid 999<\/span>\r\n\r\n# Copy our entrypoint in the container<\/span>\r\nCOPY<\/span> entrypoint.sh \/opt<\/span>\r\n\r\nUSER<\/span> 999<\/span>\r\nENTRYPOINT<\/span> [ \"\/opt\/entrypoint.sh\"<\/span> ]<\/span>\r\n<\/code><\/pre>\n
Here you see that we create a dedicated user called\u00a0kate<\/code> (User ID 999) for which we also create a home directory. This home directory is used for all files that kate<\/code>\u00a0is creating during runtime. Since we set the\u00a0readOnlyRootFilesystem<\/code>\u00a0to\u00a0true<\/code>, we must make sure that we mount some sort of writable volume (e.g EmptyDir<\/code>) to kate’s home directory. Otherwise, kate wouldn’t be able to write any runtime data then.<\/p>\n
Moreover, we have to install the following three packages:<\/p>\n
    \n
  • x11vnc<\/li>\n
  • xvfb<\/li>\n
  • kate<\/li>\n<\/ul>\n
    These are the only packages we need for our container. In addition, we also need to create an entrypoint script to start the application and prepare the container accordingly. This entrypoint script creates the configuration for kate<\/code>, starts it in a virtual display by using\u00a0xvfb-run<\/code> and provides this virtual display to end users by using the VNC server via x11vnc<\/code>. In the meantime,\u00a0xdrrinfo<\/code> is used to check if the virtual display came up successfully after starting kate<\/code>. If it takes to long, the entrypoint script will fail by returning the exit code 1.<\/p>\n
    By doing this, we ensure that the container is not stuck in an infinite loop during a failure and let Kubernetes restart the container whenever it couldn’t start the application successfully. Furthermore, it is important to check if the virtual display came up prior of handing it over to the VNC server because the VNC server would crash if the virtual display is not up and running since it needs something to share. On the other hand though, our container will be killed whenever kate<\/code> is terminated because it would also terminate the virtual display and in the end it would then also terminate the VNC server which let’s the container exit, too. This way, we don’t need take care of it by our own.<\/p>\n
    #!\/bin\/bash<\/span>\r\n\r\nset<\/span> -e<\/span>\r\n\r\n# If no resolution is provided<\/span>\r\nif<\/span> [<\/span> -z<\/span> $VNC_RESOLUTION_WIDTH<\/span> ]<\/span>;<\/span> then<\/span>\r\n  VNC_RESOLUTION_WIDTH<\/span>=<\/span>1920<\/span>\r\nfi<\/span>\r\n\r\nif<\/span> [<\/span> -z<\/span> $VNC_RESOLUTION_HEIGHT<\/span> ]<\/span>;<\/span> then<\/span>\r\n  VNC_RESOLUTION_HEIGHT<\/span>=<\/span>1080<\/span>\r\nfi<\/span>\r\n\r\n# If no server port is provided<\/span>\r\nif<\/span> [<\/span> -z<\/span> $VNC_SERVER_PORT<\/span> ]<\/span>;<\/span> then<\/span>\r\n  VNC_SERVER_PORT<\/span>=<\/span>5900<\/span>\r\nfi<\/span>\r\n\r\n# Prepare configuration for kate<\/span>\r\nmkdir<\/span> -p<\/span> $HOME<\/span>\/.local\/share\/kate\r\necho<\/span> \"[MainWindow0]\r\n\"<\/span>$VNC_RESOLUTION_WIDTH<\/span>\"x\"<\/span>$VNC_RESOLUTION_HEIGHT<\/span>\" screen: Height=$VNC_RESOLUTION_HEIGHT<\/span>\r\n\"<\/span>$VNC_RESOLUTION_WIDTH<\/span>\"x\"<\/span>$VNC_RESOLUTION_HEIGHT<\/span>\" screen: Width=$VNC_RESOLUTION_WIDTH<\/span>\r\n\"<\/span>$VNC_RESOLUTION_WIDTH<\/span>\"x\"<\/span>$VNC_RESOLUTION_HEIGHT<\/span>\" screen: XPosition=0\r\n\"<\/span>$VNC_RESOLUTION_WIDTH<\/span>\"x\"<\/span>$VNC_RESOLUTION_HEIGHT<\/span>\" screen: YPosition=0\r\nActive ViewSpace=0\r\nKate-MDI-Sidebar-Visible=false\"<\/span> ><\/span> $HOME<\/span>\/.local\/share\/kate\/anonymous.katesession\r\n\r\n# We need to define an XAuthority file<\/span>\r\nexport<\/span> XAUTHORITY<\/span><\/span>=<\/span>$HOME<\/span>\/.Xauthority\r\n\r\n# Define execution command<\/span>\r\nAPPLICATION_CMD<\/span>=<\/span>\"kate\"<\/span>\r\n\r\n# Let's start our application in a virtual display<\/span>\r\nxvfb-run \\<\/span>\r\n  -n<\/span> 99<\/span> \\<\/span>\r\n  -s<\/span> ':99 -screen 0 '<\/span>$VNC_RESOLUTION_WIDTH<\/span>'x'<\/span>$VNC_RESOLUTION_HEIGHT<\/span>'x16'<\/span> \\<\/span>\r\n  -f<\/span> $XAUTHORITY<\/span> \\<\/span>\r\n  $APPLICATION_CMD<\/span> &<\/span>\r\n\r\n# Let's wait until the virtual display is initalize before<\/span>\r\n# we proceed. But don't wait infinitely.<\/span>\r\nTIMEOUT<\/span>=<\/span>10<\/span>\r\nwhile<\/span> !<\/span> (<\/span>xdriinfo -display<\/span> :99 nscreens)<\/span>;<\/span> do<\/span> \r\n  sleep<\/span> 1<\/span>\r\n  let<\/span> TIMEOUT-=<\/span>1<\/span>\r\ndone<\/span>\r\n\r\n# Now, let's make the virtual display accessible by<\/span>\r\n# exposing it via the VNC Server that is listening on<\/span>\r\n# localhost and the specified port (e.g. 5900)<\/span>\r\nx11vnc \\<\/span>\r\n  -display<\/span> :99 \\<\/span>\r\n  -nopw<\/span> \\<\/span>\r\n  -localhost<\/span> \\<\/span>\r\n  -rfbport<\/span> $VNC_SERVER_PORT<\/span> \\<\/span>\r\n  -forever<\/span>\r\n<\/code><\/pre>\n
    After preparing those files, we can now create our image and import it to our Kubernetes cluster by using the following commands:<\/p>\n
    # Do not forget to give your entrypoint script<\/span>\r\n# the proper permissions do be executed<\/span>\r\n$ chmod<\/span> +x entrypoint.sh\r\n\r\n# Next, build the image and import it into kind,<\/span>\r\n# so that it can be used from within the clusters.<\/span>\r\n$ sudo<\/span> docker<\/span> build -t<\/span> registry.example.com\/own-app\/web-based-kate:0.0.1 .<\/span>\r\n$ sudo<\/span> kind load -n<\/span> guacamole docker-image registry.example.com\/own-app\/web-based-kate:0.0.1\r\n<\/code><\/pre>\n
    The image will be imported to\u00a0kind<\/code>, so that every workload resource operated in our kind<\/code> cluster can access it. If you use some other Kubernetes cluster, you would need to upload this to a registry that your cluster can pull images from.<\/p>\n
    Finally, we can also apply our previously created Kubernetes manifests to the cluster. Let’s say we saved everything to one file called kuberentes.yaml<\/code>. Then, you can simply apply it like this:<\/p>\n
    $ kubectl apply -f<\/span> kubernetes.yaml\r\ndeployment.apps\/web-based-kate configured\r\nsecret\/guacamole-config configured\r\nservice\/web-based-kate unchanged\r\n<\/code><\/pre>\n
    This way, a Kubernetes Deployment, Secret and Service is created which ultimately creates a Kubernetes Pod which we can access afterwards.<\/p>\n
    $ kubectl get pod\r\nNAME                              READY   STATUS    RESTARTS   AGE\r\nweb-based-kate-7894778fb6-qwp4z   3<\/span>\/3     Running   0<\/span>          10m\r\n<\/code><\/pre>\n
    Verification of our Deployment<\/h2>\n
    Now, it’s money time! After preparing everything, we should be able to access our web based kate<\/code>\u00a0application by using our web browser. As mentioned earlier, we configured\u00a0kind<\/code> in such a way that we can access our application by using our local port 30000. Every request to this port is forwarded to the kind control plane node from where it is picked up by the Kubernetes Service of type NodePort<\/code>. This one is then forwarding all requests to our designated Guacamole server container which is offering the web server for accessing remote application’s via Guacamole.<\/p>\n
    If everything works out, you should be able to see the the following login screen:<\/p>\n
    \"\"<\/p>\n
    After successfully login in, the remote connection is established and you should be able to see the welcome screen from kate<\/code>:<\/p>\n
    \"\"<\/p>\n
    If you click on\u00a0New<\/code>, you can create a new text file:<\/p>\n
    \"\"<\/p>\n
    Those text files can even be saved but keep in mind that they will only exist as long as our Kubernetes Pod exists. Once it gets deleted, the corresponding EmptyDir<\/code>, that we mounted into our kate<\/code> container, gets deleted as well and all files in it are lost. Moreover, the container is set to read-only meaning that a user can only write files to the volumes (e.g.\u00a0EmptyDir<\/code>) that we mounted to our container.<\/p>\n
    Conclusion<\/h2>\n
    After seeing that it’s relatively easy to convert every application to a web based one by using Apache Guacamole, there is only one major question left…<\/p>\n
    What do you prefer the most. Salsa or Guacamole?<\/p>\n","protected":false},"excerpt":{"rendered":"
    If you had the choice, would you rather take Salsa or Guacamole? Let me explain, why you should choose Guacamole over Salsa. In this blog article, we want to take a look at one of the smaller Apache projects out there called Apache Guacamole. Apache Guacamole allows administrators to run a web based client tool […]<\/p>\n","protected":false},"author":38,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1885],"tags":[1936,1931,1932,1941,1940,1775,1938,1933,1937,1935,1934,1838,1939],"class_list":["post-7956","post","type-post","status-publish","format-standard","hentry","category-howtos-en","tag-alpine","tag-apache","tag-apache-guacamole","tag-configmap","tag-daemonset","tag-debian-en","tag-deployment","tag-guacamole","tag-k8s","tag-kate","tag-kind","tag-kubernetes-en","tag-statefulset"],"acf":[],"yoast_head":"\nApache Guacamole - Do you prefer Salsa or Guacamole? - credativ\u00ae<\/title>\n<meta name=\"description\" content=\"Apache Guacamole allows users to easily access remote connections via their web browser. Learn more about it.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Apache Guacamole - Do you prefer Salsa or Guacamole?\" \/>\n<meta property=\"og:description\" content=\"Apache Guacamole allows users to easily access remote connections via their web browser. Learn more about it.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/\" \/>\n<meta property=\"og:site_name\" content=\"credativ\u00ae\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/credativDE\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-05-21T12:50:07+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-11-24T17:29:17+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.credativ.de\/wp-content\/uploads\/2024\/05\/Apache_Guacamole.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1600\" \/>\n\t<meta property=\"og:image:height\" content=\"640\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Michael Sprengel\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@credativde\" \/>\n<meta name=\"twitter:site\" content=\"@credativde\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Michael Sprengel\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"15 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/\"},\"author\":{\"name\":\"Michael Sprengel\",\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/#\\\/schema\\\/person\\\/a3e4af81335b70b26cda81a7690bee16\"},\"headline\":\"Apache Guacamole – Do you prefer Salsa or Guacamole?\",\"datePublished\":\"2024-05-21T12:50:07+00:00\",\"dateModified\":\"2025-11-24T17:29:17+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/\"},\"wordCount\":2518,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.credativ.de\\\/wp-content\\\/uploads\\\/2024\\\/05\\\/Apache_Guacamole-1024x410.png\",\"keywords\":[\"Alpine\",\"Apache\",\"Apache Guacamole\",\"Configmap\",\"Daemonset\",\"Debian\",\"Deployment\",\"Guacamole\",\"k8s\",\"kate\",\"kind\",\"Kubernetes\",\"Statefulset\"],\"articleSection\":[\"HowTos\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#respond\"]}],\"copyrightYear\":\"2024\",\"copyrightHolder\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/#organization\"}},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/\",\"url\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/\",\"name\":\"Apache Guacamole - Do you prefer Salsa or Guacamole? - credativ\u00ae\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.credativ.de\\\/wp-content\\\/uploads\\\/2024\\\/05\\\/Apache_Guacamole-1024x410.png\",\"datePublished\":\"2024-05-21T12:50:07+00:00\",\"dateModified\":\"2025-11-24T17:29:17+00:00\",\"description\":\"Apache Guacamole allows users to easily access remote connections via their web browser. Learn more about it.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.credativ.de\\\/wp-content\\\/uploads\\\/2024\\\/05\\\/Apache_Guacamole-1024x410.png\",\"contentUrl\":\"https:\\\/\\\/www.credativ.de\\\/wp-content\\\/uploads\\\/2024\\\/05\\\/Apache_Guacamole-1024x410.png\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Apache Guacamole – Do you prefer Salsa or Guacamole?\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/#website\",\"url\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/\",\"name\":\"credativ GmbH\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Organization\",\"Place\"],\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/#organization\",\"name\":\"credativ\u00ae\",\"url\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/\",\"logo\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#local-main-organization-logo\"},\"image\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#local-main-organization-logo\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/credativDE\\\/\",\"https:\\\/\\\/x.com\\\/credativde\",\"https:\\\/\\\/mastodon.social\\\/@credativde\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/credativ-gmbh\",\"https:\\\/\\\/www.instagram.com\\\/credativ\\\/\"],\"description\":\"Die credativ GmbH ist ein f\u00fchrendes, auf Open Source Software spezialisiertes IT-Dienstleistungs- und Beratungsunternehmen. Wir bieten umfassende und professionelle Services, von Beratung und Infrastruktur-Betrieb \u00fcber 24\\\/7 Support bis hin zu individuellen L\u00f6sungen und Schulungen. Unser Fokus liegt auf dem ganzheitlichen Management von gesch\u00e4ftskritischen Open-Source-Systemen, darunter Betriebssysteme (z.B. Linux), Datenbanken (z.B. PostgreSQL), Konfigurationsmanagement (z.B. Ansible, Puppet) und Virtualisierung. Als engagierter Teil der Open-Source-Community unterst\u00fctzen wir unsere Kunden dabei, die Vorteile freier Software sicher, stabil und effizient in ihrer IT-Umgebung zu nutzen.\",\"legalName\":\"credativ GmbH\",\"foundingDate\":\"2025-03-01\",\"duns\":\"316387060\",\"numberOfEmployees\":{\"@type\":\"QuantitativeValue\",\"minValue\":\"11\",\"maxValue\":\"50\"},\"address\":{\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#local-main-place-address\"},\"geo\":{\"@type\":\"GeoCoordinates\",\"latitude\":\"51.1732374\",\"longitude\":\"6.392010099999999\"},\"telephone\":[\"+4921619174200\",\"08002733284\"],\"contactPoint\":{\"@type\":\"ContactPoint\",\"telephone\":\"08002733284\",\"email\":\"vertrieb@credativ.de\"},\"openingHoursSpecification\":[{\"@type\":\"OpeningHoursSpecification\",\"dayOfWeek\":[\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\"],\"opens\":\"09:00\",\"closes\":\"17:00\"},{\"@type\":\"OpeningHoursSpecification\",\"dayOfWeek\":[\"Saturday\",\"Sunday\"],\"opens\":\"00:00\",\"closes\":\"00:00\"}],\"email\":\"info@credativ.de\",\"areaServed\":\"D-A-CH\",\"vatID\":\"DE452151696\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/#\\\/schema\\\/person\\\/a3e4af81335b70b26cda81a7690bee16\",\"name\":\"Michael Sprengel\",\"description\":\"Michael Sprengel has been with credativ since 2015, after completing his Bachelor degree in computer science at the University of Applied Science Hochschule Niederrhein. After his study, he started his career as a consultant here at credativ and quickly became one of the team leads in our company. His expertise ranges from DevOps, automation up to containerization.\"},{\"@type\":\"PostalAddress\",\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#local-main-place-address\",\"streetAddress\":\"Hennes-Weisweiler-Allee 23\",\"addressLocality\":\"M\u00f6nchengladbach\",\"postalCode\":\"41179\",\"addressRegion\":\"Deutschland\",\"addressCountry\":\"DE\"},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.credativ.de\\\/en\\\/blog\\\/howtos-en\\\/apache-guacamole-do-you-prefer-salsa-or-guacamole\\\/#local-main-organization-logo\",\"url\":\"https:\\\/\\\/www.credativ.de\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/credativ-logo-right.svg\",\"contentUrl\":\"https:\\\/\\\/www.credativ.de\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/credativ-logo-right.svg\",\"caption\":\"credativ\u00ae\"}]}<\/script>\n<meta name=\"geo.placename\" content=\"M\u00f6nchengladbach\" \/>\n<meta name=\"geo.position\" content=\"51.1732374;6.392010099999999\" \/>\n<meta name=\"geo.region\" content=\"Germany\" \/>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Apache Guacamole - Do you prefer Salsa or Guacamole? - credativ\u00ae","description":"Apache Guacamole allows users to easily access remote connections via their web browser. Learn more about it.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/","og_locale":"en_US","og_type":"article","og_title":"Apache Guacamole - Do you prefer Salsa or Guacamole?","og_description":"Apache Guacamole allows users to easily access remote connections via their web browser. Learn more about it.","og_url":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/","og_site_name":"credativ\u00ae","article_publisher":"https:\/\/www.facebook.com\/credativDE\/","article_published_time":"2024-05-21T12:50:07+00:00","article_modified_time":"2025-11-24T17:29:17+00:00","og_image":[{"width":1600,"height":640,"url":"https:\/\/www.credativ.de\/wp-content\/uploads\/2024\/05\/Apache_Guacamole.png","type":"image\/png"}],"author":"Michael Sprengel","twitter_card":"summary_large_image","twitter_creator":"@credativde","twitter_site":"@credativde","twitter_misc":{"Written by":"Michael Sprengel","Est. reading time":"15 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#article","isPartOf":{"@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/"},"author":{"name":"Michael Sprengel","@id":"https:\/\/www.credativ.de\/en\/#\/schema\/person\/a3e4af81335b70b26cda81a7690bee16"},"headline":"Apache Guacamole – Do you prefer Salsa or Guacamole?","datePublished":"2024-05-21T12:50:07+00:00","dateModified":"2025-11-24T17:29:17+00:00","mainEntityOfPage":{"@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/"},"wordCount":2518,"commentCount":0,"publisher":{"@id":"https:\/\/www.credativ.de\/en\/#organization"},"image":{"@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#primaryimage"},"thumbnailUrl":"https:\/\/www.credativ.de\/wp-content\/uploads\/2024\/05\/Apache_Guacamole-1024x410.png","keywords":["Alpine","Apache","Apache Guacamole","Configmap","Daemonset","Debian","Deployment","Guacamole","k8s","kate","kind","Kubernetes","Statefulset"],"articleSection":["HowTos"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#respond"]}],"copyrightYear":"2024","copyrightHolder":{"@id":"https:\/\/www.credativ.de\/#organization"}},{"@type":"WebPage","@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/","url":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/","name":"Apache Guacamole - Do you prefer Salsa or Guacamole? - credativ\u00ae","isPartOf":{"@id":"https:\/\/www.credativ.de\/en\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#primaryimage"},"image":{"@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#primaryimage"},"thumbnailUrl":"https:\/\/www.credativ.de\/wp-content\/uploads\/2024\/05\/Apache_Guacamole-1024x410.png","datePublished":"2024-05-21T12:50:07+00:00","dateModified":"2025-11-24T17:29:17+00:00","description":"Apache Guacamole allows users to easily access remote connections via their web browser. Learn more about it.","breadcrumb":{"@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#primaryimage","url":"https:\/\/www.credativ.de\/wp-content\/uploads\/2024\/05\/Apache_Guacamole-1024x410.png","contentUrl":"https:\/\/www.credativ.de\/wp-content\/uploads\/2024\/05\/Apache_Guacamole-1024x410.png"},{"@type":"BreadcrumbList","@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.credativ.de\/en\/"},{"@type":"ListItem","position":2,"name":"Apache Guacamole – Do you prefer Salsa or Guacamole?"}]},{"@type":"WebSite","@id":"https:\/\/www.credativ.de\/en\/#website","url":"https:\/\/www.credativ.de\/en\/","name":"credativ GmbH","description":"","publisher":{"@id":"https:\/\/www.credativ.de\/en\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.credativ.de\/en\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":["Organization","Place"],"@id":"https:\/\/www.credativ.de\/en\/#organization","name":"credativ\u00ae","url":"https:\/\/www.credativ.de\/en\/","logo":{"@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#local-main-organization-logo"},"image":{"@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#local-main-organization-logo"},"sameAs":["https:\/\/www.facebook.com\/credativDE\/","https:\/\/x.com\/credativde","https:\/\/mastodon.social\/@credativde","https:\/\/www.linkedin.com\/company\/credativ-gmbh","https:\/\/www.instagram.com\/credativ\/"],"description":"Die credativ GmbH ist ein f\u00fchrendes, auf Open Source Software spezialisiertes IT-Dienstleistungs- und Beratungsunternehmen. Wir bieten umfassende und professionelle Services, von Beratung und Infrastruktur-Betrieb \u00fcber 24\/7 Support bis hin zu individuellen L\u00f6sungen und Schulungen. Unser Fokus liegt auf dem ganzheitlichen Management von gesch\u00e4ftskritischen Open-Source-Systemen, darunter Betriebssysteme (z.B. Linux), Datenbanken (z.B. PostgreSQL), Konfigurationsmanagement (z.B. Ansible, Puppet) und Virtualisierung. Als engagierter Teil der Open-Source-Community unterst\u00fctzen wir unsere Kunden dabei, die Vorteile freier Software sicher, stabil und effizient in ihrer IT-Umgebung zu nutzen.","legalName":"credativ GmbH","foundingDate":"2025-03-01","duns":"316387060","numberOfEmployees":{"@type":"QuantitativeValue","minValue":"11","maxValue":"50"},"address":{"@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#local-main-place-address"},"geo":{"@type":"GeoCoordinates","latitude":"51.1732374","longitude":"6.392010099999999"},"telephone":["+4921619174200","08002733284"],"contactPoint":{"@type":"ContactPoint","telephone":"08002733284","email":"vertrieb@credativ.de"},"openingHoursSpecification":[{"@type":"OpeningHoursSpecification","dayOfWeek":["Monday","Tuesday","Wednesday","Thursday","Friday"],"opens":"09:00","closes":"17:00"},{"@type":"OpeningHoursSpecification","dayOfWeek":["Saturday","Sunday"],"opens":"00:00","closes":"00:00"}],"email":"info@credativ.de","areaServed":"D-A-CH","vatID":"DE452151696"},{"@type":"Person","@id":"https:\/\/www.credativ.de\/en\/#\/schema\/person\/a3e4af81335b70b26cda81a7690bee16","name":"Michael Sprengel","description":"Michael Sprengel has been with credativ since 2015, after completing his Bachelor degree in computer science at the University of Applied Science Hochschule Niederrhein. After his study, he started his career as a consultant here at credativ and quickly became one of the team leads in our company. His expertise ranges from DevOps, automation up to containerization."},{"@type":"PostalAddress","@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#local-main-place-address","streetAddress":"Hennes-Weisweiler-Allee 23","addressLocality":"M\u00f6nchengladbach","postalCode":"41179","addressRegion":"Deutschland","addressCountry":"DE"},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.credativ.de\/en\/blog\/howtos-en\/apache-guacamole-do-you-prefer-salsa-or-guacamole\/#local-main-organization-logo","url":"https:\/\/www.credativ.de\/wp-content\/uploads\/2025\/04\/credativ-logo-right.svg","contentUrl":"https:\/\/www.credativ.de\/wp-content\/uploads\/2025\/04\/credativ-logo-right.svg","caption":"credativ\u00ae"}]},"geo.placename":"M\u00f6nchengladbach","geo.position":{"lat":"51.1732374","long":"6.392010099999999"},"geo.region":"Germany"},"_links":{"self":[{"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/posts\/7956","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/users\/38"}],"replies":[{"embeddable":true,"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/comments?post=7956"}],"version-history":[{"count":1,"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/posts\/7956\/revisions"}],"predecessor-version":[{"id":10240,"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/posts\/7956\/revisions\/10240"}],"wp:attachment":[{"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/media?parent=7956"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/categories?post=7956"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.credativ.de\/en\/wp-json\/wp\/v2\/tags?post=7956"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
Ultimately, this configuration is consumed by kind<\/code> . With it, you can also adjust multiple other parameters of your cluster besides of just modifying the port configuration which are not mentioned here. It’s worth to take a look kate’s documentation<\/a> for this.<\/p>\n