NextcloudPi planning to discontinue its docker version with nc 25

theCalcaholic · March 28, 2023, 8:05pm

How long will my existing Docker image be supported if I’m using ownyourbits/nextcloudpi image?

We will support all minor versions of NC25 until its EOL.

This means we will keep supporting the docker version with bug fixes and security related patches until the EOL of Nextcloud 25, which is in November 2023.

You can migrate to our bare metal install, LXD container linked below, or to Nextcloud’s own AIO docker release if you wish to stay on a pre-packaged release.

NextcloudPi planning to discontinue its docker version

NextcloudPi is planning to drop support for its docker version - at least temporarily. This decision is not final, but we believe, it’s the best way to improve and further develop NCP. Please let us know below if this affects you and the listed alternatives are not feasible for you.

We, as NextcloudPi devs, have been thinking a lot lately about the direction that NextcloudPi should take in the long run. That starts with thinking about what NCP actually is and what it provides to the community.

What are the key features of NextcloudPi?

In my mind, this is what NextcloudPi brings to the table that’s not easily available anywhere else:

A nextcloud instance that’s working out of the box on your own (or arbitrary) hardware without any need to touch a terminal (“managed self-hosting”)
A web interface and many tools for performing and automating administrative tasks like
- setting up TLS certificates [1]
- choosing and implementing a backup strategy [1] [2]
- setting up dynDNS providers [1]
- and much more
Providing secure defaults for less technically inclined self-hosters, lowering the entry-barrier to self-hosting Nextcloud

What may have been a unique feature of NextcloudPi historically, but certainly isn’t anymore, is providing a single command to setup Nextcloud. There are now other tools which provide that and arguably better and more robust than NCP (e.g. Nextcloud All-in-One).

Due to the single-system architecture of NextcloudPi, we currently need to invest a huge amount of work into writing and especially testing update scripts for the various components of a NextcloudPi instance, of which the most notable are:

Nextcloud (obviously)
The apache2 webserver
The PHP process manager (PHP-FPM)
Mysql, being the database used by Nextcloud
The redis in-memory database
Nextcloud’s notify push service
The metrics providers for the server and backup monitoring
NCP’s admin web UI
The operating system itself (Debian stable)

The vast amount of work currently goes into making sure that all these components are compatible and nothing breaks during updates - despite all our efforts not without causing issues in user systems from time to time, simply because of the sheer complexity of the system as a whole.

Therefore, we intend to make more use of docker internally in NextcloudPi, replacing most of the mentioned components with docker containers. That would allow us to replace them without much risk of impairing any other services, as all services are sandboxed in their own environment.

However, this also means, we can’t provide the kind of docker image for NextcloudPi, we used to.

Why we have to discontinue the NCP docker image

As mentioned, we want to make use of docker inside of NCP. While not impossible, it is not a good idea to run docker containers inside docker containers for production scenarios. Therefore, for the time being, we will have to drop support for NCP docker. However, once we have migrated all relevant components to docker containers, NCP docker may come back as a multi-container setup. I cannot guarantee this yet, because my crystal ball broke and this lies way in the future, but it is very likely that, by moving all our services to docker, we will loose most of the constraints regarding the host system, which means:

NCP could run on any current Linux host
NCP could run behind a reverse proxy
NCP would not interfere with (most) other services

So chances are, the new NCP architecture could be used very similar to the current docker container.

What to do with my current NCP docker instance

If you are currently running an NCP instance via docker, first of all, fear not! Your instance will not suddenly break and we wil keep supporting the docker version with bug fixes and security related patches until the EOL of Nextcloud 25, which is in November 2023.

Secondly, we recommend the switch to an NCP LXD or LXC container or a VM if you want to keep using NCP. A guide on how to migrate from docker to LXD can be found here
.

Alternatively, you can migrate to Nextcloud All-In-One, the official docker deployment maintained by Nextcloud GmbH.

The LXD container offers mostly the same capabilities as the docker image (let us know if your use case doesn’t allow for it) and should work for most users.

Lastly, we are very interested in your feedback. This was a consideration that I thought about for many months and I hope that it will really benefit the development of NCP and allow us to provide more features instead of spending most of our times in testing and fixing a fragile (because complex) update process.

You are welcome to join the discussion on the Nextcloud forum or our Matrix and Telegram.
If you want to learn more about the project, feel free to check out the project’s website at nextcloudpi.com or our Github.

just · April 11, 2023, 4:11pm

30 posts were merged into an existing topic: About moving the articles

h3rb3rt · May 2, 2023, 2:54pm

Ok, even though I understand your decision on stopping to support docker, it is still my go to technology and after I migrated from bare metal to docker some 3 month ago I am more than sad to read your message.
For me the docker image was the perfect solution, to have a physical server with way too much power and running multiple services on different IPs without the VM overhead.
But ok, I got used to portainer as a docker management tool, but perhaps it is time to migrate to LXD - and learn something new.

Anyhow, very sad to start migrating again

michuvon · June 1, 2023, 3:30pm

It think it is a good decision.
Personally I think with the launch of NC AiO the overlap with NCP Docker is just too big to justify the work @theCalcaholic outlines above.
Honestly I feel Docker is already something for slightly more advanced users and if your are already on that level you can just as well install NC AiO rather then NCP.
Sure NCP still provides some features AiO does not but the list is getting shorter and shorter.

My entry to Nextcloud was with a RaspberryPi and the NCP Image for it. Back then I would have been completely turned off by that whole Docker thing and probably never even tried. The flashable images are the most easy entry into Nextcloud and I think this is what NCP excels at and is unrivaled. It’s just soooo easy and the reason I love this Project.

I guess what I’m trying to say is that I agree that the NCP team should focus it’s limited and valuable time on the NCP versions that cater to beginners and less technically inclined people.
Do one thing and do one thing well.

Thank you very much for all your work guys, I can not thank you enough.

What we need now, before EOL NC25, is a good guide on how to migrate from NCP Docker to NC AiO. Unfortunately I neither have the time nor sufficient Docker knowledge to write that.

Robert_Spierenburg · June 26, 2023, 4:55pm

This is the issue I am facing right now. I have a working NCP instance (I love the BTRFS snapshots and the LetsEncrypt features, made it SOOO much easier). I’m trying to figure out how to migrate it to the AIO docker instance. Luckily for me, its mostly files I’m concerned about so I plan on using the Data Migration plugin. But if there is a better way that isn’t too complicated then I would love to hear about it.

And thanks to all the Devs still working on NextcloudPI. I wish there was a way to implement all the extra features you have to the main Nextcloud AIO instance.

Robert

just · June 27, 2023, 4:46am

github.com/nextcloud/nextcloudpi

Containerize

opened 10:45PM - 27 Sep 22 UTC

ZendaiOwl

enhancement docker design roadmap has-updates

# Containerize NCP _A project that started from a brainstorming in the Matrix… Wiki chat room._ First post & preliminary information and all that sort of stuff :pray: A very much Work In Progress, confirming and testing if a design idea could indeed work as thought-out theoretically ## Project idea Convert NCP and it's tool into something like a "binary" application container (or containers that only do "one thing/task") and services capable of being integrated with others, also making it possible to update/upgrade parts of the whole instead of everything. Where ncp-config is the master container over the others, and this image can then be used as a service. ## End goal Containerize NCP completely ## Starting point & proof-of-concept ~~Convert `ncp-config`'s various scripts into individual containers & `ncp-config` to a container as well, being used as the master container, to control the others~~ Edit: To use one container, a bash control script (maybe?) called ncp-tools, or something, is entrypoint, possibly install it as plugin or only nc-encrypt which needs admin permissions. And put all the ncp script tools into one container directly using a bash script as a controller with case checking (?) for the different parts inside the container. Which right now seems to be the better option, but I don't know 🙏 Then combine that with nextcloud-aio, Nextcloud, PHP, mariaDB or a database and Caddy as front-end or reverse proxy, which is how I've used Caddy the most (reverse-proxy). Anyone have any other ideas? - [ ] Category re-design/re-structuring (?) - [ ] New category suggestion - BACKUP - NETWORK - SYSTEM - UPDATE Status + [ ] Stopped + [ ] Not started + [ ] Not continuing + [X] Researching + [X] Testing + [ ] Ongoing + [x] Paused ° + [ ] Completed ° As I'm finishing my undergraduate degree at the moment this is currently paused TODO 1. - [X] Added a few relevant help articles, for basic understanding around the subject of the project. 2. - [X] Added some more relevant help articles from the Docker documentation, can be really hard to find otherwise. 3. - [x] Add links and script names to the categories for ncp-config until completed 2. - [ ] Expand explanations (_partly done_) 3. - [X] Begin research 4. - [ ] Begin testing 5. - [ ] What else? .. [ncp-config]: https://github.com/nextcloud/nextcloudpi/blob/master/bin/ncp-config ## Related Help articles & Documentation information [Google - Best practice, Building containers][1] [Google - Best practice, Operating containers][2] [Docker - Best practice, Dockerfile][3] [Docker - Best practice, Development][4] [Docker - Best practice, Image-building][9] [Docker - Build enhancements][5] [Docker - Choosing a build driver][6] [Docker - Manage images][7] [Docker - Create a base image][8] [Docker - Multi-container apps][10] [Docker - Update the application][11] [Docker - Packaging your software][12] [Docker - Multi-stage builds][13] [Docker - Compose, Overview][14] [Docker - Reference, run command][15] [Docker - Specify a Dockerfile][18] [Docker - Announcement, Compose V2][16] [Red Hat Dev - Blog Post, Systemd in Containers][17] [Docker docs, Deprecated Features][docker-deprecated] [1]: https://cloud.google.com/architecture/best-practices-for-building-containers#signal-handling [2]: https://cloud.google.com/architecture/best-practices-for-operating-containers [3]: https://docs.docker.com/develop/develop-images/dockerfile_best-practices/ [4]: https://docs.docker.com/develop/dev-best-practices/ [5]: https://docs.docker.com/develop/develop-images/build_enhancements/ [6]: https://docs.docker.com/build/building/drivers/ [7]: https://docs.docker.com/develop/develop-images/image_management/ [8]: https://docs.docker.com/develop/develop-images/baseimages/ [9]: https://docs.docker.com/get-started/09_image_best/ [10]: https://docs.docker.com/get-started/07_multi_container/ [11]: https://docs.docker.com/get-started/03_updating_app/ [12]: https://docs.docker.com/build/building/packaging/ [13]: https://docs.docker.com/build/building/multi-stage/ [14]: https://docs.docker.com/compose/ [15]: https://docs.docker.com/engine/reference/run [16]: https://www.docker.com/blog/announcing-compose-v2-general-availability/ [17]: https://developers.redhat.com/blog/2019/04/24/how-to-run-systemd-in-a-container [18]: https://docs.docker.com/engine/reference/commandline/build/#specify-a-dockerfile--f [docker-deprecated]: https://docs.docker.com/engine/deprecated/ ## Notes [Docker Hub, Nextcloudpi][ncp-docker-hub] [Docker docs, IPv6 Support][docker-ipv6] [ncp-docker-hub]: https://hub.docker.com/r/ownyourbits/nextcloudpi [docker-orchestration]: https://docs.docker.com/get-started/orchestration/ [docker-ipv6]: https://docs.docker.com/config/daemon/ipv6/ A Nextcloud instance's directories to restore settings. 1. Config 2. Database 3. Data (User files & App data (?)) Commands to get IP-addresses in the terminal ```bash # INTERNAL IP-ADDRESS # IPv4 - String manipulation "$(ip addr | grep 192 | awk '{print $2}' | cut -b 1-14)" # IPv4 & IPv6 - String manipulation ip a | grep "scope global" | awk '{print $2}' | head -2 | sed 's|/.*||g' # IPv4, IPv6 & Link-local - JSON ip -j address | jq '.[2].addr_info' | jq '.[].local' # Without quotes - JSON ip -j address | jq '.[2].addr_info' | jq -r '.[].local' # IPv4 - JSON ip -j address | jq '.[2].addr_info' | jq -r '.[0].local' # IPv6 - JSON ip -j address | jq '.[2].addr_info' | jq -r '.[1].local' # Link-local - JSON ip -j address | jq '.[2].addr_info' | jq -r '.[2].local' ``` ```bash # PUBLIC IP ADDRESS # IPv4 curl -sL -m4 -4 https://icanhazip.com # IPv6 curl -sL -m4 -6 https://icanhazip.com ``` #### Docker Context [Docker docs, Manage contexts](https://docs.docker.com/engine/reference/commandline/context/) #### Docker Buildx ```bash docker buildx build . \ --file /path/Dockerfile \ --tag ${OWNER}/${REPO}:${TAG} # In this context it's regarding the docker hub # Owner, Repo & Tag @DockerHub ``` Options - `--platform` + Architecture(s) for the image - `--builder` - `--push` - `--build-arg` Create builder ```bash docker buildx create --use \ --name container \ --driver docker-container \ --platform linux/arm64,linux/amd64,linux/armhf ``` [Docker Driver][docker-driver] [docker-driver]: https://docs.docker.com/build/building/drivers/docker/ - `docker` - `docker-container` _Recommended for multiple architecture compatibility_ - `kubernetes` [Orchestration][docker-orchestration] - `Docker Swarm` _Default_ - `Kubernetes` _Deprecated in stack & context @v20.10 [Source](https://docs.docker.com/engine/deprecated/#kubernetes-stack-and-context-support)_ #### Docker Compose [Docker docs, Compose extend services][docker-extend-services] [Docker docs, Compose networking][compose-networking] [Docker docs, Compose in production][compose-production] [Docker docs, Compose V2 compatibility][compose-v2-compat] [Docker docs, Compose FAQ][compose-faq] [docker-extend-services]: https://docs.docker.com/compose/extends/ [compose-networking]: https://docs.docker.com/compose/networking/ [compose-production]: https://docs.docker.com/compose/production/ [compose-v2-compat]: https://docs.docker.com/compose/cli-command-compatibility/ [compose-faq]: https://docs.docker.com/compose/faq/ Old syntax - V1 - `docker-compose` New syntax - V2 - `docker compose` <details><summary>Ex. docker-compose.yml</summary> ```yaml services: nextcloudpi: command: "$(ip addr | grep 192 | awk '{print $2}' | cut -b 1-14)" container_name: nextcloudpi image: ownyourbits/nextcloudpi:latest ports: - published: 80 target: 80 - published: 443 target: 443 - published: 4443 target: 4443 restart: unless-stopped volumes: - ncdata:/data:ro - /etc/localtime:/etc/localtime:ro version: '3.3' volumes: ncdata: external: true ``` </details>  #### Docker Run A working `docker run` command with the `--init` flag for PID 1 management and reaping of zombie processes. ```bash docker run --init \ --publish 4443:4443 \ --publish 443:443 \ --publish 80:80 \ --volume ncdata:/data \ --name nextcloudpi \ --detach ownyourbits/nextcloudpi:latest \ "$(ip addr | grep 192 | awk '{print $2}' | cut -b 1-14)" ``` - `"$(ip addr | grep 192 | awk '{print $2}' | cut -b 1-14)"` _Greps an IP-address beginning with 192, modify to fit your system, test in terminal._ _See "Commands to get IP-addresses in the terminal" above for other examples._ [Nextcloud AIO][nextcloud-aio] _Used as example and reference_ <details><summary>Docker Run AIO arm64</summary> ```bash sudo docker run \ --sig-proxy=false \ --name nextcloud-aio-mastercontainer \ --restart always \ --publish 80:80 \ --publish 8080:8080 \ --publish 8443:8443 \ --volume nextcloud_aio_mastercontainer:/mnt/docker-aio-config \ --volume /var/run/docker.sock:/var/run/docker.sock:ro \ nextcloud/all-in-one:latest-arm64 ``` </details> [Reverse proxy AIO][aio-reverse-proxy] [nextcloud-aio]: https://github.com/nextcloud/all-in-one [aio-reverse-proxy]: https://github.com/nextcloud/all-in-one/blob/main/reverse-proxy.md #### Dockerfile [Docker docs, Dockerfile reference][dockerfile-ref] [dockerfile-ref]: https://docs.docker.com/engine/reference/builder/ Naming scheme - `Dockerfile.name` Instead of using the ARG example below and getting each individual script. Use [alpine-git][alpinegit] image instead and clone repo, alternatively clone it beforehand [alpinegit]: https://hub.docker.com/r/alpine/git `ADD` can be used in Dockerfile to import scripts - `ADD ${URL} ${PATH}` URL to fetch scripts in raw text + `https://raw.githubusercontent.com/` + Ex. `https://raw.githubusercontent.com/${OWNER}/${REPO}/${BRANCH}/${PATH}` <details><summary> Ex. Docker ARG</summary> ARG|DESCRIPTION -:|:- OWNER|Repository owner @ GitHub REPO|Repository @ GitHub BRANCH|Branch of repository @ GitHub PATH|Path to the script directory CATEGORY|Category in /bin/ncp (PATH) PATH_BASH|Path to bash binary URL|GH URL to get scripts in raw text _ARG Example_ ```docker ARG OWNER ["nextcloud"] ARG REPO ["nextcloudpi"] ARG BRANCH ["master"] ARG PATH ["bin/ncp"] ARG CATEGORY ["BACKUPS"] ARG SCRIPT ["nc-backup-auto.sh"] ARG URL ["https://raw.githubusercontent.com"] ARG PATH_BASH ["/usr/local/bin/bash"] ADD ["${URL}/${OWNER}/${REPO}/${BRANCH}/${PATH}/${CATEGORY}/${SCRIPT}","${PATH}/${CATEGORY}/${SCRIPT}"] COPY --from=bash ["$PATH_BASH", "$PATH_BASH"] RUN ["$PATH_BASH","-c","chmod +x ${PATH}/${CATEGORY}/${SCRIPT}"] SHELL ["$PATH_BASH"] ENTRYPOINT ["$PATH_BASH","-c","${PATH}/${CATEGORY}/${SCRIPT}"] ``` </details> ### Existing Containers - [Nextcloud][nextcloud] - [Nextcloud AIO][nextcloud-aio] - [Linuxserver.io/Nextcloud][linuxserver-nextcloud] - [MariaDB][mariadb] - [MySQL][mysql] - [PHP][php] - [Debian][debian] - [Alpine][alpine] - [Bash][bash] - [Curl][curl] - Apache2 - Caddy [nextcloud]: https://hub.docker.com/_/nextcloud [linuxserver-nextcloud]: https://hub.docker.com/r/linuxserver/nextcloud [mariadb]: https://hub.docker.com/_/mariadb [mysql]: https://hub.docker.com/_/mysql [php]: https://hub.docker.com/_/php [debian]: https://hub.docker.com/_/debian [alpine]: https://hub.docker.com/_/alpine [bash]: https://hub.docker.com/_/bash [curl]: https://hub.docker.com/r/curlimages/curl #### Dockerized Bash Scripts - Examples 1. [Transforming Bash Script to Docker Compose][ex1] 2. [Automatic Docker Container creation w/bash script][ex2] 3. [Docker w/Shell script or Makefile][ex3] 4. [Run scripts, Docker arguments][ex4] 5. [Run a scripts inside Docker container using Shell script][ex5] 6. [Run Script, with dev docker image][ex6] [ex1]: https://fiberplane.dev/blog/transforming-bash-scripts-into-docker-compose/ [ex2]: https://assistanz.com/automatic-docker-container-creation-via-linux-bash-script/ [ex3]: https://ypereirareis.github.io/blog/2015/05/04/docker-with-shell-script-or-makefile/ [ex4]: https://devopscube.com/run-scripts-docker-arguments/ [ex5]: https://www.commands.dev/workflows/run_a_script_inside_a_docker_container_using_a_shell_script [ex6]: https://gist.github.com/austinhyde/2e39c01d6b0ebf4aef7409e129c47ea7 [dirCategories]: https://github.com/nextcloud/nextcloudpi/tree/containerize/bin/ncp [dirBackups]: https://github.com/nextcloud/nextcloudpi/tree/containerize/bin/ncp/BACKUPS [dirConfig]: https://github.com/nextcloud/nextcloudpi/tree/containerize/bin/ncp/CONFIG [dirNetworking]: https://github.com/nextcloud/nextcloudpi/tree/containerize/bin/ncp/NETWORKING [dirSecurity]: https://github.com/nextcloud/nextcloudpi/tree/containerize/bin/ncp/SECURITY [dirSystem]: https://github.com/nextcloud/nextcloudpi/tree/containerize/bin/ncp/SYSTEM [dirTools]: https://github.com/nextcloud/nextcloudpi/tree/containerize/bin/ncp/TOOLS [dirUpdates]: https://github.com/nextcloud/nextcloudpi/tree/containerize/bin/ncp/UPDATES --- #### Scripts, Dependencies & Packages > _IMPORTANT_ Script shebang must be `#!/usr/bin/env bash` and not `#!/bin/bash`, to be compatible with the `bash` [docker image][bash] natively. > Notes > There are a few main things that are important to note regarding this image: > > Bash itself is installed at /usr/local/bin/bash, not /bin/bash, so the recommended shebang is #!/usr/bin/env bash, not #!/bin/bash (or explicitly running your script via bash /.../script.sh instead of letting the shebang invoke Bash automatically). The image does not include /bin/bash, but if it is installed via the package manager included in the image, that package will install to /bin/bash and might cause confusion (although /usr/local/bin is ahead of /bin in $PATH, so as long as plain bash or /usr/bin/env are used consistently, the image-provided Bash will be preferred). > > Bash is the only thing included, so if your scripts rely on external tools (such as jq, for example), those will need to be added manually (via apk add --no-cache jq, for example). ## Nestybox & Sysbox Sysbox, an open-source runc, it's project was acquired by Docker, Inc. and they help solve the user permissions issue (mapping of user id) inside the docker containers [Nestybox website](https://www.nestybox.com/) Quote from [Sysbox GitHub page](https://github.com/nestybox/sysbox) Sysbox solves problems such Enhancing the isolation of containerized microservices (root in the container maps to an unprivileged user on the host). Enabling a highly capable root user inside the container without compromising host security. Securing CI/CD pipelines by enabling Docker-in-Docker (DinD) or Kubernetes-in-Docker (KinD) without insecure privileged containers or host Docker socket mounts. Enabling the use of containers as "VM-like" environments for development, local testing, learning, etc., with strong isolation and the ability to run systemd, Docker, IDEs, and more inside the container. Running legacy apps inside containers (instead of less efficient VMs). Replacing VMs with an easier, faster, more efficient, and more portable container-based alternative, one that can be deployed across cloud environments easily. Partitioning bare-metal hosts into multiple isolated compute environments with 2X the density of VMs (i.e., deploy twice as many VM-like containers as VMs on the same hardware at the same performance). Partitioning cloud instances (e.g., EC2, GCP, etc.) into multiple isolated compute environments without resorting to expensive nested virtualization. --- Packages in Docker environment/build <details><summary> Docker Packages</summary> DOCKER PACKAGES|| :-:|:-: `git`|`bash` </details> Extraction of the different environment variables, dependencies on/in other scripts & their dependencies in turn and which packages are required together with their location. <details><summary>File & location</summary> |File|Repository|Installed|Dependencies :-:|:-:|:-:|:-: `library.sh`|`/etc/library.sh`|`/usr/local/etc/library.sh`|`$ncc`,`$ARCH`,`$NCPCFG`,`$CFGDIR`,`$BINDIR`,`$NCDIR` `ncc`|`/bin/ncc`|`/usr/local/bin/ncc`|`occ`,`$NCDIR` `ncp.cfg`|`/etc/ncp.cfg`|`/usr/local/etc/ncp.cfg`|`-` `occ`|`-`|`/var/www/nextcloud/`|`$NCDIR` </details> <details><summary>Environment variables</summary> |ENVIRONMENT VARIABLE|VALUE| -:|:- `$ncc`|`/usr/local/bin/ncc` `$CFGDIR`|`/usr/local/etc/ncp-config.d/` `$BINDIR`|`/usr/local/bin/ncp/` `$NCDIR`|`/var/www/nextcloud/` `$NCPCFG`|`"${NCPCFG:-etc/ncp.cfg}"` `$ARCH`|`"$(dpkg --print-architecture)"` `$DESTDIR`|`` `$INCLUDEDATA`|`` `$COMPRESS`|`` ncp-tools: `$BACKUPLIMIT`|`` `$BACKUPDAYS`|`` `$NCLATESTVER`|`$(jq -r .nextcloud_version < "$NCPCFG")` `$PHPVER`|`$(jq -r .php_version < "$NCPCFG")` `$RELEASE`|`$(jq -r .release < "$NCPCFG")` `$NEXTCLOUD_URL`|`https://localhost sudo -E -u www-data "/var/www/nextcloud/apps/notify_push/bin/${ARCH}/notify_push" --allow-self-signed /var/www/nextcloud/config/config.php &>/dev/null &` </details> <details><summary>Packages</summary> ||PACKAGES|| :-:|:-:|:-: `dpkg`|`bash`|`jq`| `apt`|`dialog`|`cat`| `awk`|`mktemp`|`sudo`| </details> <details><summary>Users</summary> USERS| :-: `www-data`| </details> <details><summary>Permissions</summary> PERMISSIONS| :-: `sudo`| </details>  ---

Robert_Spierenburg · June 27, 2023, 2:02pm

So am I understanding this properly? This is just taking the NCP commands and putting them all into a container that could be “added on” to the NCP AIO?

That would be amazing!

HenrysCat · July 16, 2023, 1:49pm

So are these just the same?

https://hub.docker.com/r/linuxserver/nextcloud

HenrysCat · July 16, 2023, 1:57pm

Or this?

just · July 16, 2023, 2:05pm

They are all different, because anyone can post up a docker container. AIO is the latest docker build maintained by Nextcloud.

HenrysCat · July 16, 2023, 2:17pm

Thank you, just what I needed to know.

theCalcaholic · November 20, 2023, 4:47pm

@Robert_Spierenburg If we can pull it off, that’s basically the longterm roadmap for NCP
I would love to make NCP into a wrapper around NC AIO and concentrate on the additional features it brings to the table.

But whether we will be able to integrate it like this technically is not clear yet.