dockerdockerfilebitbucketbitbucket-server

Reputation: 905

How to start Bitbucket server as a container in detached mode?

Many questions exists about how to run containers in detached mode.

My question though is kinda specific to running Atlassian Bitbucket server in detached mode containers.

I tried the below as the last layer in my dockerfile and when i run the container with -d the process is not started

RUN /opt/atlassian-bitbucket/bin/start-bitbucket.sh

I tried using ENTRYPOINT like below

ENTRYPOINT ["/opt/atlassian-bitbucket/bin/start-bitbucket.sh"]

but container always exits after the start script completes.

Not sure if anyone has setup a Bitbucket Data center in containers but i am curious to see how they would have run multiple containers of the same image and made them join a single cluster.

Upvotes: 1

Answers (3)

Emmanuel Spencer Egbuniwe

Reputation: 484

If you use the command to spin up the bitbucket container, you'll get the message below after the build:

The path /data/bitbucket is not shared from the host and is not known to Docker. You can configure shared paths from Docker -> Preferences... -> Resources -> File Sharing.

Upvotes: 0

daveruinseverything

Reputation: 5177

Full disclosure: I work for Atlassian Premier Support, work closely with our Bitbucket Server team, and have been the primary maintainer of the atlassian/bitbucket-server Docker image for the past couple of years.

Short version

First: Use our official image, there are a host of problems we've solved over the years so rather than trying to start from scratch use ours as a base.

Second: You can indeed run a Data Center cluster in Docker. My personal test environment consists of 3 cluster nodes and a couple of Smart Mirrors, all using the official image, with HAProxy in front acting as a load balancer and an external Elasticsearch instance managing search. Check out the README above for a list of common configuration options - the ones you'll likely need can be set by passing environment variables

Long Version

AKA "How can I spin up a full DC cluster in a test environment?"

Here's a simple tutorial I put together for our own internal support teams a long time ago. It uses a custom HAProxy Docker container to give you an out-of-the-box load balancer. It's intended for testing on a single host, so if you want to do something different or closer to a production deployment, this won't cover that.

There's a lot to cover here, so let's start with the basics.

Networking

There are a few ways to connect up individual Docker containers so they can find each other and communicate (e.g. the --link parameter), but a Docker Network is by far the most flexible. With a dedicated network, we get the following:

Inter-container communication: Containers on the same network can communicate with each other and access services from other containers without the need to publish specific ports to the host.
Automatic DNS: Containers can find each other via their container name (defined by the --name parameter). Unlike real DNS however, when a container is down its DNS resolution ceases to exist. This can cause some issues for services like HAProxy - but we'll get to that later. Also worth noting is that this does not set the machine's hostname, which needs to be set separately if required.
Static IP assignment: For certain use cases it's useful to give Docker containers static IP addresses within their network
Multicast: Docker networks support multicast by default, which is perfect for Data Center nodes communicating over Hazelcast

One thing a Docker network doesn't do is attach the host to its network, so you, the user, can't connect to containers by container name, and you still need to publish ports to the local machine. However, there are situations where doing this is both useful and necessary. The simplest workaround is to add entries to your hosts file that point each container name you wish to access to the loopback address, 127.0.0.1

To create a Docker network, run the following command. In my example we're going to name our network atlasNetwork. If you want to use another name, remember to change the network name in all subsequent docker commands.

docker network create --driver bridge \
    --subnet=10.255.0.0/16 \
    atlasNetwork

Here, we're creating a network using the bridge driver - this is the simplest type of network. More complex network types allow the network to span multiple hosts. We're also manually specifying the subnet - if we leave this out Docker will choose one at random, and it could conflict with an existing network subnet, so it's safest to choose our own. We're also specifying a /16 mask to allow us to use IP address ranges within the last two octets - this will come up later!

Storage

Persistent data such as $BITBUCKET_HOME, or your database files, need to be stored somewhere outside of the container itself. For our test environment, we can simply store these directly on the host, our local OS. This means we can edit config files using our favourite text editor, which is pretty handy! In the examples below, we're going to store our data files in the folder ~/dockerdata. There's no need to create this folder or any subfolders, as Docker will do this automatically. If you want to use a different folder, make sure to update the examples below.

You may wonder why we're not using Docker's named volumes instead of mounting folders on the host. Named volumes are an easier to manage abstraction and are generally recommended; however for the purposes of a test environment (particularly on Docker for Mac, where you don't have direct access to the virtualised file system) there's a huge practical benefit to being able to examine each container's persistent data directly. You may want to edit a number of configuration files in Bitbucket, or Postgres, or HAProxy, and this can be difficult when using a named volume, as it requires you to open a shell into the container - and many containers don't contain basic text editor utilities (not even vi!). However, if you prefer to use volumes, you can do so simply by replacing the host folder with the named volume in all of the below examples.

Database

The first service we need on our network is a database. Let's create a Postgres instance:

docker run -d \
    --name postgres \
    --restart=unless-stopped \
    -e POSTGRES_PASSWORD=mysecretpassword \
    -e PGDATA=/var/lib/postgresql/data/pgdata \
    -v ~/dockerdata/postgres:/var/lib/postgresql/data/pgdata \
    --network=atlasNetwork \
    -p 5432:5432 \
    postgres:latest

Let's examine what we're doing here:

-d
- Run the container and detach from it (return to the prompt). Without this option, when the container starts we'll be attached directly to its stdout, and cancelling out would stop the container.
--name postgres
- Set the name of the container to postgres, which also acts as its DNS record on our network.
--restart=unless-stopped
- Sets the container to automatically start when Docker starts, unless you have explicitly stopped the container. This way, when you restart your computer, Postgres comes back up automatically
-e POSTGRES_PASSWORD=mysecretpassword
- Sets password for the default postgres user to mysecretpassword
-e PGDATA=/var/lib/postgresql/data/pgdata
- The official Postgres docker image recommends specifying this custom location when mounting the data folder to an external volume
-v ~/dockerdata/postgres:/var/lib/postgresql/data/pgdata
- Mounts the folder /var/lib/postgresql/data/pgdata inside the container to an external volume, located on the host at ~/dockerdata/postgres. This folder will be created automatically
--network=atlasNetwork
- Joins the container to our custom Docker network
-p 5432:5432
- Publishes the Postgres port to the host machine, so we can access Postgres on localhost:5432. This isn't necessary for other containers to access the service, but it is necessary for us to get to it
postgres:latest
- The latest version of the official Postgres docker image

Run the command, and hey presto, you can now access a fully functioning Postgres instance. For the sake of consistency, you may want to add your very first hosts entry here:

127.0.0.1   postgres

Now you, and any running containers, can access the instance at postgres:5432 Before you move on, you should connect to your database using your DB admin tool of choice. Connect to the hostname postgres with the username postgres, the default database postgres and the password mysecretpassword, and create a Bitbucket database ready to go:

CREATE USER bitbucket WITH PASSWORD 'bitbucket';
CREATE DATABASE bitbucket WITH OWNER bitbucket ENCODING 'UTF8';

If you don't have a DB admin tool handy, you can create a DB by using docker exec to run psql directly in the container:

# We need to run two commands because psql won't let
# you run CREATE DATABASE from a multi-command string

docker exec -it postgres psql -U postgres -c \
    "CREATE USER bitbucket WITH PASSWORD 'bitbucket';"
docker exec -it postgres psql -U postgres -c \
    "CREATE DATABASE bitbucket WITH OWNER bitbucket ENCODING 'UTF8';"

Elasticsearch

The next service we'll set up is Elasticsearch. We need a dedicated instance that all of our Data Center nodes can access. We have a great set of instructions on how to install a compatible version, configure it for use with Bitbucket, and install Atlassian's buckler security plugin: Install and configure a remote Elasticsearch instance So how do we set this up in Docker? Well, it's easy:

docker pull dchevell/bitbucket-elasticsearch:latest

docker run -d \
    --name elasticsearch \
    -e AUTH_BASIC_USERNAME=bitbucket \
    -e AUTH_BASIC_PASSWORD=mysecretpassword \
    -v ~/dockerdata/elastic:/usr/share/elasticsearch/data \
    --network=atlasNetwork \
    -p 9200:9200 \
    dchevell/bitbucket-elasticsearch:latest

Simply put, dchevell/bitbucket-elasticsearch is a pre-configured Docker image that is set up according to the instructions on Atlassian's Install and configure a remote Elasticsearch instance KB article. Atlassian's Buckler security plugin is installed for you, and you can configure the username and password with the environment variables seen above. Again, we're mounting a data volume to our host machine, joining it to our Docker network, and publishing a port so we can access it directly. This is solely for troubleshooting purposes, so if you want to poke around in your local Elasticsearch instance without going through Bitbucket, you can.

Now we're done, you can add your second hosts entry:

127.0.0.1   elasticsearch

HAProxy

Next, we'll set up HAProxy. Installing Bitbucket Data Center provides some example configuration, and again, we have a pre-configured Docker image that does all the hard work for us. But first, there's a few things we need to figure out first. HAProxy doesn't play well with a Docker network's DNS system. In the real world, if a system is down, the DNS record still exists and connections will simply time out. HAProxy handles this scenario just fine. But in a Docker network, when a container is stopped, its DNS record ceases to exist, and connections to it fail with an "Unknown host" error. HAProxy won't start when this happens, which means we can't configure it to proxy connections to our nodes by container name. Instead, we will need to give each node a static IP address, and configure HAProxy to use the IP address instead.

Even though we have yet to create our nodes, we can decide on the IP addresses for them now. Our Docker network's subnet is 10.255.0.0/16, and Docker will dynamically assign containers addresses on the last octet (e.g. 10.255.0.1, 10.255.0.2 and so on). Since we know this, we can safely assign our Bitbucket nodes static IP addresses using the second-last octet:

10.255.1.1
10.255.1.2
10.255.1.3

With that out of the way, there's one more thing. HAProxy is going to be the face of our instance, so its container name is going to represent the URL we use to access the instance. In this example, we'll call it bitbucketdc. We're also going to set the host name of the machine to be the same.

docker run -d \
    --name bitbucketdc \
    --hostname bitbucketdc \
    -v ~/dockerdata/haproxy:/usr/local/etc/haproxy \
    --network=atlasNetwork \
    -e HTTP_NODES="10.255.1.1:7990,10.255.1.2:7990,10.255.1.3:7990" \
    -e SSH_NODES="10.255.1.1:7999,10.255.1.2:7999,10.255.1.3:7999" \
    -p 80:80 \
    -p 443:443 \
    -p 7999:7999 \
    -p 8001:8001 \
    dchevell/bitbucket-haproxy:latest

In the above example, we're specifying the HTTP endpoints of our future Bitbucket nodes, as well as the SSH endpoints, as a comma separated list. The container will turn this into valid HAProxy configuration. The proxied services will be available on port 80 and port 443, so we're publishing them both. This container is configured to automatically generate a self-signed SSL certificate based on the hostname of the machine, so we have HTTPS access available out of the box.

Since we're proxying SSH as well, we're also publishing port 7999, Bitbucket Server's default SSH port. You'll notice we're also publishing port 8001. This is to access HAProxy's Admin interface, so we can monitor which nodes are detected as up or down at any given time.

Lastly, we're mounting HAProxy's config folder to a data volume. This isn't really necessary, but it will let you directly access haproxy.cfg so you can get a feel for the configuration options there.

Now it's time for our third hosts entry. This one is , since it impacts things like Base URL access, is absolutely required

127.0.0.1   bitbucketdc

Bitbucket nodes

Finally we're ready to create our Bitbucket nodes. Since these are all going to be accessed via the load balancer, we don't have to publish any ports. However, for troubleshooting and testing purposes there are times when you'll want to hit a particular node directly, so we're going to publish each node to a different local port so we can access it directly when needed.

docker run -d \
    --name=bitbucket_1 \
    -e ELASTICSEARCH_ENABLED=false \
    -e HAZELCAST_NETWORK_MULTICAST=true \
    -e HAZELCAST_GROUP_NAME=bitbucket-docker \
    -e HAZELCAST_GROUP_PASSWORD=bitbucket-docker \
    -e SERVER_PROXY_NAME=bitbucketdc \
    -e SERVER_PROXY_PORT=443 \
    -e SERVER_SCHEME=https \
    -e SERVER_SECURE=true \
    -v ~/dockerdata/bitbucket-shared:/var/atlassian/application-data/bitbucket/shared \
    --network=atlasNetwork \
    --ip=10.255.1.1 \
    -p 7001:7990 \
    -p 7991:7999 \
    atlassian/bitbucket-server:latest

docker run -d \
    --name=bitbucket_2 \
    -e ELASTICSEARCH_ENABLED=false \
    -e HAZELCAST_NETWORK_MULTICAST=true \
    -e HAZELCAST_GROUP_NAME=bitbucket-docker \
    -e HAZELCAST_GROUP_PASSWORD=bitbucket-docker \
    -e SERVER_PROXY_NAME=bitbucketdc \
    -e SERVER_PROXY_PORT=443 \
    -e SERVER_SCHEME=https \
    -e SERVER_SECURE=true \
    -v ~/dockerdata/bitbucket-shared:/var/atlassian/application-data/bitbucket/shared \
    --network=atlasNetwork \
    --ip=10.255.1.2 \
    -p 7002:7990 \
    -p 7992:7999 \
    atlassian/bitbucket-server:latest

docker run -d \
    --name=bitbucket_3 \
    -e ELASTICSEARCH_ENABLED=false \
    -e HAZELCAST_NETWORK_MULTICAST=true \
    -e HAZELCAST_GROUP_NAME=bitbucket-docker \
    -e HAZELCAST_GROUP_PASSWORD=bitbucket-docker \
    -e SERVER_PROXY_NAME=bitbucketdc \
    -e SERVER_PROXY_PORT=443 \
    -e SERVER_SCHEME=https \
    -e SERVER_SECURE=true \
    -v ~/dockerdata/bitbucket-shared:/var/atlassian/application-data/bitbucket/shared \
    --network=atlasNetwork \
    --ip=10.255.1.3 \
    -p 7003:7990 \
    -p 7993:7999 \
    atlassian/bitbucket-server:latest

You can see that we're specifying the static IP addresses we decided on when we set up HAProxy. It's up to you whether you add hosts entries for these nodes, or simply access their ports via localhost. Since no other containers need to access our nodes via host name, it's not really necessary, and I personally haven't bothered.

The official Docker image adds the ability to set a Docker-only variable, ELASTICSEARCH_ENABLED=false to prevent Elasticsearch from starting in the container. The remaining Hazelcast properties are natively supported in the official docker image, because Bitbucket 5 is based on Springboot and can automatically translate environment variables to their equivalent dot properties for us.

Turn it all on

Now we're ready to go!

Access your instance on https://bitbucketdc (or whatever name you chose). Add a Data Center evaluation license (You can generate a 30 day one on https://my.atlassian.com) and connect it to your Postgres database. Log in, then go to Server Admin and connect your Elasticsearch instance (remember, it's running on port 9200, so set the Elasticsearch URL to http://elasticsearch:9200 and use the username and password we configured when we created the Elasticsearch container.

Visit the Clustering section in Server Admin, and you should see all of the nodes there, demonstrating that Multicast is working and the nodes have found each other.

That's it! Your Data Center instance is fully operational. You can use it as your daily instance by shutting down all but one node, and simply use it as a single node test instance - then, whenever you need, turn on the additional nodes.

Upvotes: 4