docs/source/builds/building-images.rst

# Creating & building images

1) start with running the required database for the build stage in the background.
   
    ```
    docker-compose up --detach database
    ```
   
    This will start our postgres database, and expose it to the network.
    Postgres DB is configured to output logs into a stdout

2) We can now run the full installation. Database needs to be running for the next build command.
   This will build the rhodecode base image used for rhodecode, vcsserver, celery, ssh, svn
   Then it will build all other components required.

    ```
    docker-compose build rhodecode
    docker-compose build
    ```

4) Once we build all required containers, we can run the whole stack using `docker-compose up`

    ```
    docker-compose up
    ```


# Standalone cluster build from installer

If you;d like to build your own custom image here's a quick how to.:
Follow these steps to build and run the RhodeCode Cluster via Docker-compose.

1) Run:

    ./rcstack init

2) Run artifacts fetch like installer and certain needed build binaries:

   Start by fetching required installer binaries. This is required to create both
   simple build and full compose setup.
   Please use the `--version-name VERSION_NAME` flag to adjust RhodeCode version if needed.
   (e.g. --version-name "4.24.1")
   
   ```
   ./rcstack get-build-artifacts
   ```
   
    This will download required installer files and put them into the `.cache` directory. 
    This directory should look similar to that after downloads have finish:
    
    ```
    drwxr-xr-x   8 rcdev  rcdev   256B Feb  8 13:35 .
    drwxr-xr-x  14 rcdev  rcdev   448B Feb  8 10:40 ..
    -rw-r--r--   1 rcdev  rcdev     0B Feb  8 20:44 .dirkeep
    -rwxr-xr-x   1 rcdev  rcdev   241M Feb  8 13:35 RhodeCode-installer-linux-build20210208_0800
    -rw-r--r--   1 rcdev  rcdev   156M Feb  8 13:35 RhodeCodeCommunity-4.24.1+x86_64-linux_build20210208_0800.tar.bz2
    -rw-r--r--   1 rcdev  rcdev   171M Feb  8 13:35 RhodeCodeEnterprise-4.24.1+x86_64-linux_build20210208_0800.tar.bz2
    -rw-r--r--   1 rcdev  rcdev   145M Feb  8 13:35 RhodeCodeVCSServer-4.24.1+x86_64-linux_build20210208_0800.tar.bz2
    -rw-r--r--   1 rcdev  rcdev   109M Feb  8 13:35 locale-archive
    ```


3) Create the build

    ./rcstack build-installer

# Standalone cluster build from source code

There's an option to build the latest release from the source code as a docker installation.
If you;d like to build your own custom image based on the source code here's a quick how to.:
Follow these steps to build and run the RhodeCode Cluster via Docker-compose.

1) Run init to setup needed docker env and files:

    ./rcstack init

2) Run artifacts fetch like installer and certain needed build binaries:

   Start by fetching required installer binaries.
   Only local-archive is required to be present, installer is disregarded for source build
   
   ```
   ./rcstack get-build-artifacts
   ```
   
    This will download required installer files and put them into the `.cache` directory. 
    This directory should look similar to that after downloads have finish:
    
    ```
    drwxr-xr-x   8 rcdev  rcdev   256B Feb  8 13:35 .
    drwxr-xr-x  14 rcdev  rcdev   448B Feb  8 10:40 ..
    -rw-r--r--   1 rcdev  rcdev     0B Feb  8 20:44 .dirkeep
    -rwxr-xr-x   1 rcdev  rcdev   241M Feb  8 13:35 RhodeCode-installer-linux-build20210208_0800
    -rw-r--r--   1 rcdev  rcdev   156M Feb  8 13:35 RhodeCodeCommunity-4.24.1+x86_64-linux_build20210208_0800.tar.bz2
    -rw-r--r--   1 rcdev  rcdev   171M Feb  8 13:35 RhodeCodeEnterprise-4.24.1+x86_64-linux_build20210208_0800.tar.bz2
    -rw-r--r--   1 rcdev  rcdev   145M Feb  8 13:35 RhodeCodeVCSServer-4.24.1+x86_64-linux_build20210208_0800.tar.bz2
    -rw-r--r--   1 rcdev  rcdev   109M Feb  8 13:35 locale-archive
    ```

3) get source code needed to create a build

    This step will create source code copies into the `.source/` path. So it will look like this:
    
   ```
    -rw-r--r-- 1 docker docker    0 Nov 25 12:27 .dirkeep
    drwxr-xr-x 1 docker docker 1184 Nov 25 12:27 rhodecode-enterprise-ce
    drwxr-xr-x 1 docker docker 1120 Nov 25 12:27 rhodecode-enterprise-ee
    drwxr-xr-x 1 docker docker  800 Nov 25 12:27 rhodecode-vcsserver
    ```

    If you have the 3 required projects source code already, this step can be omitted, and the 
    sources can be copied to the `.source/` directory. note: symlinks don't work.

    - https://code.rhodecode.com/rhodecode-vcsserver
    - https://code.rhodecode.com/rhodecode-enterprise-ce
    - https://code.rhodecode.com/rhodecode-enterprise-ee (assuming access is granted to this)

    Run this to fetch the sources

    ```
    ./rcstack get-build-source --revision=default --auth-token=xxxx --server-url=https://code.rhodecode.com/sources
    ```


4) Create the build
   
    ```
    ./rcstack build-source --version-name 4.28.0.REL.2022.12.12
    ```
   

_Disk space problems?_
     
```
docker system df
docker builder prune -f
# optionally
docker image prune -a
```


## Simple community build

Build docker RhodeCode `Community` without any dependencies (redis, external db) using 
simple sqlite database and file based caches. 
This is a fully running instance good for small use with 3-5 users.

```
docker build -t rhodecode/rhodecode-ce:4.23.2 -f rhodecode.dockerfile \
-e RHODECODE_TYPE=Community \
-e RHODECODE_VERSION=4.23.2 \
-e RHODECODE_DB=sqlite \
-e RHODECODE_USER_NAME=admin \
-e RHODECODE_USER_PASS=secret4 \
-e RHODECODE_USER_EMAIL=[e-mail] \
.
```

note: for debugging better to add `--progress plain` into the build command to obtain all the output from the build.
To Build against existing running Postgres or MySQL you can specify:

    --build-arg RHODECODE_DB=postgresql://postgres:secret@database/rhodecode
    --build-arg RHODECODE_DB=mysql://root:secret@localhost/rhodecode?charset=utf8


To copy over the data into volumes use such command:
```
docker run -v logvolume:/data --name data_vol busybox true
docker cp . data_vol:/data
docker rm data_vol
```

Run the container, mounting the required volumes. By default the application would be
available at http://localhost:10020, and default login is (unless specified differently in the build command)

```
user: admin
password: secret4
```

We've not built our image using specific version. It's time to run it:
We specify the run.ini by selecting config option we have locally

```
docker run \
  --name rhodecode-container \
  --publish 10020:10020 \
  --restart unless-stopped \
  --volume $PWD/config:/etc/rhodecode/conf \
  --volume $PWD/config/rhodecode.ini:/etc/rhodecode/conf_build/rhodecode.ini \
  'rhodecode/rhodecode-ee:4.23.2'
```

Enter container

```
docker exec -it rhodecode-container /bin/bash
```

Enter interactive shell

```
docker exec -it rhodecode-container /usr/local/bin/rhodecode_bin/bin/rc-ishell /etc/rhodecode/conf/rhodecode.ini
```

Run Database migrations
```
docker exec -it rhodecode-container /usr/local/bin/rhodecode_bin/bin/rc-upgrade-db /etc/rhodecode/conf/rhodecode.ini --force-yes
```



### Registry for docker swarm

docker run -d -p 5000:5000 --restart always --name registry registry:2