ArangoDB: How to initialize the server language / license update (#2449)

arangodb/content.md

@@ -18,8 +18,8 @@ ArangoDB runs everywhere: On-prem, in the cloud, and as a managed cloud service:
 
 #### ArangoDB Documentation
 
--	[Learn ArangoDB](https://www.arangodb.com/learn/)
--	[Documentation](https://www.arangodb.com/docs/)
+-	[Learn ArangoDB](https://arangodb.com/learn/)
+-	[Documentation](https://docs.arangodb.com/)
 
 ## How to use this image
 
@@ -28,26 +28,44 @@ ArangoDB runs everywhere: On-prem, in the cloud, and as a managed cloud service:
 In order to start an ArangoDB instance, run:
 
 ```console
-unix> docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 -d --name arangodb-instance %%IMAGE%%
+docker run -d -p 8529:8529 -e ARANGO_RANDOM_ROOT_PASSWORD=1 --name arangodb-instance %%IMAGE%%
 ```
 
-Will create and launch the %%IMAGE%% docker instance as background process. The Identifier of the process is printed. By default ArangoDB listen on port 8529 for request and the image includes `EXPOSE 8529`. If you link an application container it is automatically available in the linked container. See the following examples.
+Docker chooses the processor architecture for the image that matches your host CPU by default. If this is not the case, for example, because you have the `DOCKER_DEFAULT_PLATFORM` environment variable set to a different architecture, you can pass the `--platform` flag to the `docker run` command to specify the appropriate operating system and architecture for the container. For x86-64, use `linux/amd64`. On ARM, especially Apple silicon with no emulation for the required AVX instruction set extension, use `linux/arm64/v8`:
 
-In order to get the IP arango listens on, run:
+```console
+docker run -d -p 8529:8529 -e ARANGO_RANDOM_ROOT_PASSWORD=1 --name arangodb-instance --platform linux/arm64/v8 %%IMAGE%%
+```
+
+This creates and launches the %%IMAGE%% Docker instance as a background process. The Identifier of the process is printed. By default, ArangoDB listens on port `8529` for requests.
+
+In order to get the IP ArangoDB listens on, run:
 
 ```console
-unix> docker inspect --format '{{ .NetworkSettings.IPAddress }}' arangodb-instance
+docker inspect --format '{{ .NetworkSettings.IPAddress }}' arangodb-instance
 ```
 
+### Initialize the server language
+
+When using Docker, you need to specify the language you want to initialize the server to on the first run in one of the following ways:
+
+-	Set the environment variable `LANG` to a locale in the `docker run` command, e.g. `-e LANG=sv` for a Swedish locale.
+
+-	Use an `arangod.conf` configuration file that sets a language and mount it into the container. For example, create a configuration file on your host system in which you set `icu-language = sv` at the top (before any `[section]`) and then mount the file over the default configuration file like `docker run -v /your-host-path/arangod.conf:/etc/arangodb3/arangod.conf ...`.
+
+Note that you cannot set the language using only a startup option on the command-line, like `docker run ... %%IMAGE%% --icu-language sv`.
+
+If you don't specify a language explicitly, the default is `en_US` up to ArangoDB v3.11 and `en_US_POSIX` from ArangoDB v3.12 onward.
+
 ### Using the instance
 
-In order to use the running instance from an application, link the container:
+To use the running instance from an application, link the container:
 
 ```console
-unix> docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 --name my-app --link arangodb-instance:db-link %%IMAGE%%
+docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 --name my-app --link arangodb-instance:db-link %%IMAGE%%
 ```
 
-This will use the instance with the name `arangodb-instance` and link it into the application container. The application container will contain environment variables
+This uses the instance named `arangodb-instance` and links it into the application container. The application container contains environment variables, which can be used to access the database.
 
 	DB_LINK_PORT_8529_TCP=tcp://172.17.0.17:8529
 	DB_LINK_PORT_8529_TCP_ADDR=172.17.0.17
@@ -55,14 +73,12 @@ This will use the instance with the name `arangodb-instance` and link it into th
 	DB_LINK_PORT_8529_TCP_PROTO=tcp
 	DB_LINK_NAME=/naughty_ardinghelli/db-link
 
-These can be used to access the database.
-
 ### Exposing the port to the outside world
 
 If you want to expose the port to the outside world, run:
 
 ```console
-unix> docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 -p 8529:8529 -d %%IMAGE%%
+docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 -p 8529:8529 -d %%IMAGE%%
 ```
 
 ArangoDB listen on port 8529 for request and the image includes `EXPOSE
@@ -93,7 +109,7 @@ Note: this way of specifying logins only applies to single server installations.
 You can pass arguments to the ArangoDB server by appending them to the end of the Docker command:
 
 ```console
-unix> docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 %%IMAGE%% --help
+docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 %%IMAGE%% --help
 ```
 
 The entrypoint script starts the `arangod` binary by default and forwards your arguments.
@@ -101,13 +117,18 @@ The entrypoint script starts the `arangod` binary by default and forwards your a
 You may also start other binaries, such as the ArangoShell:
 
 ```console
-unix> docker run -it %%IMAGE%% arangosh --server.database myDB ...
+docker run -it %%IMAGE%% arangosh --server.database myDB ...
 ```
 
 Note that you need to set up networking for containers if `arangod` runs in one container and you want to access it with `arangosh` running in another container. It is easier to execute it in the same container instead. Use `docker ps` to find out the container ID / name of a running container:
 
 ```console
-unix> docker ps
+docker ps
+```
+
+It prints something similar to the following:
+
+```console
 CONTAINER ID   IMAGE     COMMAND                 CREATED      STATUS      PORTS                   NAMES
 1234567890ab   arangodb  "/entrypoint.sh aran…"  2 hours ago  Up 2 hours  0.0.0.0:8529->8529/tcp  jolly_joker
 ```
@@ -115,10 +136,10 @@ CONTAINER ID   IMAGE     COMMAND                 CREATED      STATUS      PORTS
 Then use `docker exec` and the ID / name to run something inside of the existing container:
 
 ```console
-unix> docker exec -it jolly_joker arangosh
+docker exec -it jolly_joker arangosh
 ```
 
-See more information about [Configuration](https://www.arangodb.com/docs/stable/administration-configuration.html)
+For more information, see the ArangoDB documentation about [Configuration](https://docs.arangodb.com/stable/operations/administration/configuration/).
 
 ### Limiting resource utilization
 
@@ -149,7 +170,7 @@ ArangoDB supports two different storage engines from version 3.2 to 3.6. You can
 
 ArangoDB uses the volume `/var/lib/arangodb3` as database directory to store the collection data and the volume `/var/lib/arangodb3-apps` as apps directory to store any extensions. These directories are marked as docker volumes.
 
-See `docker inspect --format "{{ .Config.Volumes}}" arangodb` for all volumes.
+See `docker inspect --format "{{ .Config.Volumes }}" %%IMAGE%%` for all volumes.
 
 A good explanation about persistence and docker container can be found here: [Docker In-depth: Volumes](http://container42.com/2014/11/03/docker-indepth-volumes/), [Why Docker Data Containers are Good](https://medium.com/@ramangupta/why-docker-data-containers-are-good-589b3c6c749e)
 
@@ -160,8 +181,8 @@ You can map the container's volumes to a directory on the host, so that the data
 ```console
 unix> mkdir /tmp/arangodb
 unix> docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 -p 8529:8529 -d \
-          -v /tmp/arangodb:/var/lib/arangodb3 \
-          %%IMAGE%%
+        -v /tmp/arangodb:/var/lib/arangodb3 \
+        %%IMAGE%%
 ```
 
 This will use the `/tmp/arangodb` directory of the host as database directory for ArangoDB inside the container.
@@ -171,22 +192,22 @@ This will use the `/tmp/arangodb` directory of the host as database directory fo
 Alternatively you can create a container holding the data.
 
 ```console
-unix> docker create --name arangodb-persist %%IMAGE%% true
+docker create --name arangodb-persist %%IMAGE%% true
 ```
 
 And use this data container in your ArangoDB container.
 
 ```console
-unix> docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 --volumes-from arangodb-persist -p 8529:8529 %%IMAGE%%
+docker run -e ARANGO_RANDOM_ROOT_PASSWORD=1 --volumes-from arangodb-persist -p 8529:8529 %%IMAGE%%
 ```
 
 If want to save a few bytes you can alternatively use [busybox](https://hub.docker.com/_/busybox) or [alpine](https://hub.docker.com/_/alpine) for creating the volume only containers. Please note that you need to provide the used volumes in this case. For example
 
 ```console
-unix> docker run -d --name arangodb-persist -v /var/lib/arangodb3 busybox true
+docker run -d --name arangodb-persist -v /var/lib/arangodb3 busybox true
 ```
 
-### Using as a base image
+### Usage as a base image
 
 If you are using the image as a base image please make sure to wrap any CMD in the [exec](https://docs.docker.com/reference/dockerfile/#cmd) form. Otherwise the default entrypoint will not do its bootstrapping work.
 
@@ -194,4 +215,4 @@ When deriving the image, you can control the instantiation via putting files int
 
 -	`*.sh` - files ending with .sh will be run as a bash shellscript.
 -	`*.js` - files will be executed with arangosh. You can specify additional arangosh arguments via the `ARANGOSH_ARGS` environment variable.
--	`dumps/` - in this directory you can place subdirectories containing database dumps generated using [arangodump](https://www.arangodb.com/docs/stable/programs-arangodump.html). They can be restored using [arangorestore](https://www.arangodb.com/docs/stable/programs-arangorestore.html).
+-	`dumps/` - in this directory you can place subdirectories containing database dumps generated using [arangodump](https://docs.arangodb.com/stable/components/tools/arangodump/). They can be restored using [arangorestore](https://docs.arangodb.com/stable/components/tools/arangorestore/).

arangodb/license.md

@@ -1 +1,7 @@
-[ArangoDB itself is licensed under the Apache License](https://github.com/arangodb/arangodb/blob/devel/LICENSE), but it contains [software of third parties under their respective licenses](https://github.com/arangodb/arangodb/blob/devel/LICENSES-OTHER-COMPONENTS.md).
+The official Docker images of the ArangoDB Community Edition are governed by the [ArangoDB Community License](https://arangodb.com/community-license/). The use for commercial purposes is limited to a 100 GB on dataset size in production within a single cluster and a maximum of three clusters.
+
+The source code of the Community Edition is available under the [Business Source License 1.1 (BUSL-1.1)](https://github.com/arangodb/arangodb/blob/devel/LICENSE). Copying, modification, redistribution, non-commercial use, and commercial use in a non-production context are always allowed. Additionally, you can deploy BUSL-licensed ArangoDB source code for any purpose (including production) as long as you are not creating a commercial derivative work or offering, or are including it in a commercial product, application, or service. On the fourth anniversary of the first publicly available distribution of a specific version, the license changes to the permissive Apache 2.0 open-source license.
+
+Up to ArangoDB version 3.11, ArangoDB is licensed under the [Apache 2.0 License](https://github.com/arangodb/arangodb/blob/3.11/LICENSE).
+
+ArangoDB contains [software of third parties under their respective licenses](https://github.com/arangodb/arangodb/blob/devel/LICENSES-OTHER-COMPONENTS.md).