The Raspberry Pi is awesome, and I've been using it for various fun projects for years. In preparing for this article, I counted six of various vintages doing things around my house, from enabling my garage doors to be opened through Apple Carplay in my car as I approach home, to contributing air traffic control data from aircraft landing and departing nearby Denver International Airport to the FlightAware project.
As a MongoDB fan (and — full disclosure — an employee), I've grown accustomed to the power, flexibility, and ease of use of working with document data model databases in my projects. While the excellent MongoDB Atlas cloud offering is always an option (including its big-enough-to-be-useful free tier), for some projects running on devices like Raspberry Pi, it's nice to have a local database. Until recently, though, the most up-to-date version of MongoDB that could be installed on a Raspberry Pi was version 4.4.18. Later versions — including all 5.x, 6.x, and 7.x releases — require the ARMv8.2-A microarchitecture when running on ARM64 processors, but the processors used by Raspberry Pi on its models up to and including Raspberry Pi 4 only supported ARMv8.0. This means more recently introduced MongoDB features haven't been available on Pi deployments.
With the recent introduction of the rather splendid Raspberry Pi 5, however, ARMv8.2-A is now supported, and all current MongoDB releases can once again be installed on this amazing device. Pi 5 is blazing fast compared with prior versions, too, and it's plenty capable of allowing you to run all kinds of fun projects and experimentations.
In this article, I'll show you how to install MongoDB Community Edition version 7.0.x on a Pi 5 running Pi OS "bookworm" (the latest versions of MongoDB and Pi OS respectively as of January 2024). Much of this is based on an earlier article written by my colleague Mark Smith, but Mark was constrained by the Pi hardware available at the time he wrote his article to install MongoDB 4.4, so we'll bring that advice up to date.
What you will need
A Raspberry Pi 5b: These come in 4GB and 8GB variants. Depending on how ambitious you're planning to be with your projects, I'd recommend an 8GB board, but I've had MongoDB up and running on older Raspberry Pis with as little as 2GB of RAM.
A microSD memory card: This will be the Pi's primary storage. You could probably get a working installation on a 4GB card, but that's not going to leave much room for data or logs. For this article, I'll be using a 128GB U3 card from Samsung. A good quality card from a reputable brand with high read and write speeds is worth the investment.
A USB flash drive: We'll be using this to temporarily boot your Raspberry Pi in order to modify the partitions on your main microSD card before we use it for the first time. You'll need a drive with around 3GB of storage for this and we will be reformatting it so make sure you back up any existing data that's on it first.
A computer to run the Raspberry Pi Imager: Any machine running Windows or Mac OS will work as long as it can read your microSD card and your USB flash drive. I'll be using my main Mac laptop for this.
Now we know what we need, let's review the steps we're going to follow:
1. Flash Raspberry Pi OS onto your microSD card and USB flash drive.
2. Modify the partitions on your microSD card.
3. Create XFS filesystems to run MongoDB on.
4. Install and configure MongoDB.
Let's get started.
Flash Pi OS onto your microSD card and USB flash drive
Raspberry Pi makes a handy tool available for flashing an operating system image onto storage devices. You can download it from the Raspberry Pi website. We'll use this tool to flash an operating system image onto both our microSD card and our USB flash drive
The tool gives you a bunch of options as to which operating system to flash, and any of the 64-bit Pi OS or Ubuntu (desktop or server — not core) options will work. Just be sure not to select a 32-bit version. For this article, I'm going to use Pi OS 64-bit Lite and the instructions assume you do too, but there shouldn't be too many places where you'll need to modify any of the instructions if — for example — you want to run Ubuntu instead. Pi OS Lite does not include a desktop environment, but the image is quite a bit smaller as a result, and I'll be doing everything in a terminal over SSH anyway.
Let's start by flashing your microSD card.
Select your microSD card as the target storage and click Next.
If you've selected one of the Pi OS options to flash, you'll now be asked if you want to apply any OS customizations. I highly recommend you do this. It'll allow you to preconfigure your Pi's hostname, select a username and password (and avoid the pitfall of using a default username and password), apply wireless network settings, set locale details, and enable SSH — including using public key authentication if you wish. If you don't do this now, you'll need to do all those things manually when you first boot your Pi.
Once you've finished configuring the OS customizations you want to apply, start the flashing process. This will take a few minutes to complete. Once it's complete, remove the card from your computer.
IMPORTANT: Do not insert the card into your Pi and boot from it yet.
Repeat these steps to flash Raspberry Pi OS onto your USB flash drive.
Modify the partitions on your microSD card
Linux supports several different filesystems, each with its own strengths and weaknesses. It's possible, common even, to have Linux systems with a mix of partitions using different filesystems with each partition being used for a different purpose or application type.
Without going into detail, the XFS
filesystem is particularly well suited to database-type workloads and is MongoDB's recommended filesystem. Pi OS and Ubuntu are both based on Debian Linux and the default filesystem on Debian is ext4
. In reality, MongoDB will run just fine on ext4
for any workload you are likely to run on a Raspberry Pi, but you will get a warning message when logging in to the MongoDB shell if it is not running on XFS
. If, like me, warning messages bug the heck out of you, the following steps will show you how to set up XFS
on your Pi OS image, starting with modifying the partitions on your microSD card. While setting up XFS
partitions is not absolutely necessary, it's a useful exercise to go through in case you ever find yourself setting up servers for larger workloads in the future.
When the Raspberry Pi Imager flashed your card, it created two partitions — a ~500MB FAT32
boot partition and a second ~2GB ext4
data partition:
If you do nothing else, the first time you insert your microSD card into your Pi and boot from it, the ext4
data partition will be expanded to use up all remaining space on the card. This would be a problem for us as it would leave no space for the XFS
partitions we want to add.
To prevent this, and before we boot our Pi from the microSD card, we're going to first boot it using the USB flash drive and then carry out the following steps:
1. Manually resize the ext4
data partition on our microSD card to the size we want it to be.
2. Using the remaining space on the microSD card, add two additional partitions: one for MongoDB's data files and one for its logs.
By taking these steps, when the Pi first boots from the microSD card, the ext4
file system will be automatically expanded to fill its now larger partition, but the partition itself will not be expanded to take up any additional space on the card.
Note: Over the years, Raspberry Pi has updated and modified the way that the first-boot partition resizing works, and there are a number of articles on the web showing methods to prevent it that are no longer applicable.
Insert your USB flash drive into your Pi, but do not insert your microSD card yet. Power on your Pi.
When it first boots, your Pi will power-cycle a couple of times, but after 20 to 30 seconds, it should be available for you to SSH into (assuming you enabled SSH during the flash process). If you didn't enable SSH or for some reason you can't determine the IP address it was allocated, you may need to initially connect it to a keyboard and monitor to log on directly, enable SSH, and get its IP address. Once you are able to SSH onto the Pi, insert your microSD card into the microSD card reader and use the lsblk
command to inspect its disk and partitions:
graeme@pi5Temp:~ $ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
sda 8:0 1 7.5G 0 disk
├─sda1 8:1 1 512M 0 part /boot/firmware
└─sda2 8:2 1 7G 0 part /
mmcblk0 179:0 0 119.4G 0 disk
├─mmcblk0p1 179:1 0 512M 0 part
└─mmcblk0p2 179:2 0 2G 0 part
The output on my machine shows two devices. The partitions on the sda
device are already mounted at /boot/firmware
and /
, so that's the device the Pi booted from i.e. the USB flash drive. That means the other device — mmcblk0
— is our microSD card and the device we want to partition. The reported size of the devices confirms this.
Running as a superuser, start the parted
partitioning utility and select the device to partition:
graeme@pi5Temp:~ $ sudo parted
GNU Parted 3.4
Using /dev/sda
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) select /dev/mmcblk0
Using /dev/mmcblk0
(parted) print
Model: SD YD4QD (sd/mmc)
Disk /dev/mmcblk0: 128GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 4194kB 541MB 537MB primary fat32 lba
2 541MB 2739MB 2198MB primary ext4
My microSD card is 128GB, so I'm going to expand my ext4
partition to be 30GB, then add a 20GB log partition for MongoDB and use the remaining space for a MongoDB data partition. Let's start by resizing the ext4
partition. Note that it was listed as partition 2:
(parted) resizepart
Partition number? 2
End? [2739MB]? 30.5GB
(parted) print
Model: SD YD4QD (sd/mmc)
Disk /dev/mmcblk0: 128GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 4194kB 541MB 537MB primary fat32 lba
2 541MB 30.5GB 30.0GB primary ext4
Now, we'll add the 20GB MongoDB log partition:
(parted) mkpart
Partition type? primary/extended? primary
File system type? [ext2]? xfs
Start? 30.5GB
End? 50.5GB
(parted) print
Model: SD YD4QD (sd/mmc)
Disk /dev/mmcblk0: 128GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 4194kB 541MB 537MB primary fat32 lba
2 541MB 30.5GB 30.0GB primary ext4
3 30.5GB 50.5GB 20.0GB primary xfs lba
Finally, add the MongoDB data partition using the remaining space (~77.5GB):
(parted) mkpart
Partition type? primary/extended? primary
File system type? [ext2]? xfs
Start? 50.5GB
End? 128GB
(parted) print
Model: SD YD4QD (sd/mmc)
Disk /dev/mmcblk0: 128GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 4194kB 541MB 537MB primary fat32 lba
2 541MB 30.5GB 30.0GB primary ext4
3 30.5GB 50.5GB 20.0GB primary xfs lba
4 50.5GB 128GB 77.7GB primary xfs lba
Close parted
and do a final check to make sure everything looks good using lsblk
:
(parted) quit
Information: You may need to update /etc/fstab.
graeme@pi5Temp:~ $ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
sda 8:0 1 7.5G 0 disk
├─sda1 8:1 1 512M 0 part /boot/firmware
└─sda2 8:2 1 7G 0 part /
mmcblk0 179:0 0 119.4G 0 disk
├─mmcblk0p1 179:1 0 512M 0 part
├─mmcblk0p2 179:2 0 27.9G 0 part
├─mmcblk0p3 179:3 0 18.6G 0 part
└─mmcblk0p4 179:4 0 72.3G 0 part
If everything looks good, you can power down your Pi, remove the USB flash drive (we won't be needing it any more) and with your microSD card still in the Pi's microSD card reader, power up the Pi again.
Create XFS filesystems to run MongoDB on
Your Pi will now boot using the microSD card. As before when we booted using the USB flash drive, your Pi will power-cycle a couple of times, but after 20 to 30 seconds it should be available for you to SSH into. Note you may have to delete some entries in the ssh known_hosts file on the machine from which you are connecting to the Pi to avoid SSH connection errors due to the remote host having changed identity. On "UNIX-ish" operating systems like Mac and Linux, this is usually in a hidden directory called .ssh
in your home directory. On Windows, it will depend on terminal application you are using. PuTTY, for example, stores known hosts in the registry at \HKEY_CURRENT_USER\Software\SimonTatham\PuTTY\SshHostKeys
.
Once you are able to SSH onto the Pi, do so and inspect its disk and partitions:
graeme@pi5PIOS:~ $ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
mmcblk0 179:0 0 119.4G 0 disk
├─mmcblk0p1 179:1 0 512M 0 part /boot/firmware
├─mmcblk0p2 179:2 0 27.9G 0 part /
├─mmcblk0p3 179:3 0 18.6G 0 part
└─mmcblk0p4 179:4 0 72.3G 0 part
graeme@pi5PIOS:~ $ df -h
Filesystem Size Used Avail Use% Mounted on
udev 3.8G 0 3.8G 0% /dev
tmpfs 805M 5.1M 800M 1% /run
/dev/mmcblk0p2 28G 1.7G 25G 7% /
tmpfs 4.0G 0 4.0G 0% /dev/shm
tmpfs 5.0M 48K 5.0M 1% /run/lock
/dev/mmcblk0p1 510M 63M 448M 13% /boot/firmware
tmpfs 805M 0 805M 0% /run/user/1000
In particular, we're looking to confirm our ext4
filesystem has been expanded to fill its full 30GB partition, and we have the two empty partitions ready to have XFS
filesystems added.
As everything looks good, we can add the XFS
filesystems. Start by making sure Pi OS is fully up-to-date by running apt-get update
and apt-get upgrade
.
graeme@pi5PIOS:~ $ sudo apt-get -y update
graeme@pi5PIOS:~ $ sudo apt-get upgrade
Now, we can install XFS
itself:
graeme@pi5PIOS:~ $ sudo apt-get -y install xfsprogs
If you recall the output from lsblk
, our two empty partitions are mmcblk0p3
and mmcblk0p4
. To create an XFS
file system on each, run the following commands:
graeme@pi5PIOS:~ $ sudo mkfs.xfs /dev/mmcblk0p3
graeme@pi5PIOS:~ $ sudo mkfs.xfs /dev/mmcblk0p4
Now we have our two partitions with XFS
filesystems, we need to mount them in the right locations within our directory structure. MongoDB writes logs to /var/log/mongodb
and data files to /var/lib/mongodb
, so let's go ahead and create those:
graeme@pi5PIOS:~ $ sudo mkdir /var/log/mongodb
graeme@pi5PIOS:~ $ sudo mkdir /var/lib/mongodb
We can now mount the filesystems. mmcblk0p3
is our 20GB log partition and mmcblk0p4
is our larger data partition, so the commands to run are:
graeme@pi5PIOS:~ $ sudo mount /dev/mmcblk0p3 /var/log/mongodb
graeme@pi5PIOS:~ $ sudo mount /dev/mmcblk0p4 /var/lib/mongodb
Confirm the mounts were successful:
graeme@pi5PIOS:~ $ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
mmcblk0 179:0 0 119.4G 0 disk
├─mmcblk0p1 179:1 0 512M 0 part /boot/firmware
├─mmcblk0p2 179:2 0 27.9G 0 part /
├─mmcblk0p3 179:3 0 18.6G 0 part /var/log/mongodb
└─mmcblk0p4 179:4 0 72.3G 0 part /var/lib/mongodb
The final step in this stage is to add entries to the fstab
file so that the new XFS
filesystems are mounted each time your Pi is booted. To do this, we'll use the blkid
command to get the PARTUUID
of the two XFS
partitions:
graeme@pi5PIOS:~ $ sudo blkid /dev/mmcblk0p3
/dev/mmcblk0p3: UUID="7fee4d44-6820-4e90-861f-defd195e5205" BLOCK_SIZE="512" TYPE="xfs" PARTUUID="de9255b2-03"
graeme@pi5PIOS:~ $ echo 'PARTUUID=de9255b2-03 /var/log/mongodb xfs defaults 1 1 ' | sudo tee -a /etc/fstab
graeme@pi5PIOS:~ $ sudo blkid /dev/mmcblk0p4
/dev/mmcblk0p4: UUID="d8a6e88b-fba9-4719-96d4-327829c5cd8f" BLOCK_SIZE="512" TYPE="xfs" PARTUUID="de9255b2-04"
graeme@pi5PIOS:~ $ echo 'PARTUUID=de9255b2-04 /var/lib/mongodb xfs defaults 1 1 ' | sudo tee -a /etc/fstab
Reboot your Pi and do a final check to confirm the XFS
file systems have been mounted as expected.
Install and configure MongoDB
With our disk partitioned and XFS
file systems in place, we're now ready to install MongoDB.
Do not simply run
sudo apt-get install mongoDB
. Like much software, the version of MongoDB in the standard repositories for most Linux distributions is very old and most likely no longer supported. The steps in this guide will show you how to install the latest version from MongoDB's own repositories.
At the time of writing, there are pre-built MongoDB packages for both Debian and Ubuntu which, like Pi OS, is Debian-based. However, the Debian packages only support AMD_64 architectures, whereas the Ubuntu packages also support the ARM64 architecture used by the Raspberry Pi. As of January 2024, the latest Pi OS release is based on Debian 12 ("bookworm"), as is Ubuntu 22.04 LTS ("Jammy"), so we'll use the MongoDB packages for that version of Ubuntu. It's worth pointing out that supported platforms and versions will evolve over time, so it's always worth confirming availability in the official MongoDB installation documentation.
To get started, we need to install the MongoDB public GPG key:
curl -fsSL https://pgp.mongodb.com/server-7.0.asc | \
sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg \
--dearmor
Next, create an apt source list file for the Ubuntu 22.04 packages:
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
Reload the local package database:
sudo apt-get update
And, finally, install MongoDB:
sudo apt-get install -y mongodb-org
Yay — MongoDB is now installed!!! Before we can run it, though, we need to change ownership of the /var/log/mongodb
and /var/lib/mongodb
directories to a user and group created by the installation process.
sudo chown mongodb:mongodb /var/log/mongodb/
sudo chown mongodb:mongodb /var/lib/mongodb/
Pi OS uses the systemd
init system, so to start, stop, or check the run status of MongoDB, we use the systemctl
command:
graeme@pi5PIOS:~ $ sudo systemctl start mongod
graeme@pi5PIOS:~ $ sudo systemctl status mongod
graeme@pi5PIOS:~ $ sudo systemctl stop mongod
If you want MongoDB to start automatically each time your Pi boots, use the systemctl
command to "enable" it:
graeme@pi5PIOS:~ $ sudo systemctl enable mongod
Start MongoDB and use the systemctl status
command to confirm it is running. If everything is good, you should now be able to connect using the monogsh
MongoDB shell:
graeme@pi5PIOS:~ $ mongosh
Current Mongosh Log ID: 659f7f5de9e80a30c96e4be1
Connecting to: mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.1.1
Using MongoDB: 7.0.5
Using Mongosh: 2.1.1
For mongosh info see: https://docs.mongodb.com/mongodb-shell/
To help improve our products, anonymous usage data is collected and sent to MongoDB periodically (https://www.mongodb.com/legal/privacy-policy).
You can opt-out by running the disableTelemetry() command.
------
The server generated these startup warnings when booting
2024-01-10T22:38:09.322-07:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
2024-01-10T22:38:09.322-07:00: vm.max_map_count is too low
------
test>
So far so good, but we want to fix those two warnings that were generated. The first, about access control, is the important one, and we'll handle that in a moment, but first, let's get rid of the max_map_count
warning. As with running on XFS
, this is also probably unnecessary for any workload we're likely to deploy on a Raspberry Pi, but the MongoDB Production Operations Checklist documentation recommends setting it to 102400, so let's do it.
echo 102400 | sudo tee /proc/sys/vm/max_map_count
#Persist across reboots
echo vm.max_map_count=102400 | sudo tee -a /etc/sysctl.conf
Restart MongoDB using sysctl restart mongod
, then connect with mongosh
again and verify the max_map_count
warning is no longer displayed:
graeme@pi5PIOS:~ $ sudo systemctl restart mongod
graeme@pi5PIOS:~ $ mongosh
Current Mongosh Log ID: 65a011a4cbbd56fd63aafa0e
Connecting to: mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.1.1
Using MongoDB: 7.0.5
Using Mongosh: 2.1.1
For mongosh info see: https://docs.mongodb.com/mongodb-shell/
------
The server generated these startup warnings when booting
2024-01-11T09:04:43.178-07:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
------
test>
Great — we can now deal with the access control warning and, as we said before, this one is important.
By default, MongoDB is installed to allow anyone access to the database without authentication, but only from the device on which it is running. This means that right now, we can only access it from the Raspberry Pi itself. That might be fine if all access is from applications running on the same device, as could well be the case with deployments on something like a Raspberry Pi. In most cases, though, we will want to open up network access to MongoDB, and we will certainly want to restrict access to only authenticated users.
Let's start by adding a user. Using the mongosh
shell, run the following command:
use admin
db.createUser( { user: "admin",
pwd: "YOURPASSWORDGOESHERE",
roles: [ "userAdminAnyDatabase",
"dbAdminAnyDatabase",
"readWriteAnyDatabase"] } )
Replace YOURPASSWORDGOESHERE with an actual password (all the usual recommendations about password complexity and length apply). The roles granted to user admin
by this command give them access to all data and allows them to administer other users, so keep that password secure.
Now we'll modify MongoDB's configuration file to tell it to enforce user authentication and to listen for connections on all of the Pi's network adaptors (rather than the default of listening only on it's internal loopback adaptor).
Using your preferred editor, modify /etc/mongod.conf
. You need to change the bindIp
setting from 127.0.0.1 to 0.0.0.0 (keep port
set to 27017), and you need to uncomment the security:
entry and add a new value under it, authorization: enabled
:
net:
port: 27017
bindIp: 0.0.0.0
security:
authorization: enabled
Note this is a YAML file, so the indentation is important.
Restart MongoDB once again and connect with mongosh
— now, there should be no warnings:
graeme@pi5PIOS:~ $ sudo systemctl restart mongod
graeme@pi5PIOS:~ $ mongosh
Current Mongosh Log ID: 65a01ab52a2e9d6bb7c7a3f4
Connecting to: mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.1.1
Using MongoDB: 7.0.5
Using Mongosh: 2.1.1
For mongosh info see: https://docs.mongodb.com/mongodb-shell/
test>
It's worth pointing out at this point that what we've done is open up access to MongoDB from any device that can establish a network connection to your Raspberry Pi. I'm assuming you are running on a home or office network with a firewall between you and the open internet. Pi OS itself does not have any firewall protections enabled by default. If you want to add them,
ufw
is a pretty good option. Suffice it to say, it's almost never a good idea to expose a database server to the open internet, and certainly not one without authentication enabled. You will also want to enable TLS encryption if you're deploying on, or enabling access from, anything other than your home network. Check out the MongoDB security checklist for more security advice.
To test network connectivity and authentication, move to another computer with mongosh
installed (I'm using my Mac laptop), and attempt to connect to MongoDB on your Pi. We'll do this twice: once using an anonymous login and once using the credentials for the admin
user we created. On both attempts, we'll attempt to run a command to list all databases and verify the anonymous connection is blocked from doing so:
graeme@M-YYV2WV29DD ~ % mongosh --host 10.0.0.191
Current Mongosh Log ID: 65a01c72db8f065eddfc3e9b
Connecting to: mongodb://10.0.0.191:27017/?directConnection=true&appName=mongosh+2.1.1
Using MongoDB: 7.0.5
Using Mongosh: 2.1.1
For mongosh info see: https://docs.mongodb.com/mongodb-shell/
test> db.adminCommand({listDatabases: 1})
MongoServerError: Command listDatabases requires authentication
graeme@M-YYV2WV29DD ~ % mongosh --host 10.0.0.191 -u "admin"
Enter password: ********
Current Mongosh Log ID: 65a01e554a71d545c503bc2e
Connecting to: mongodb://<credentials>@10.0.0.191:27017/?directConnection=true&appName=mongosh+2.1.1
Using MongoDB: 7.0.5
Using Mongosh: 2.1.1
For mongosh info see: https://docs.mongodb.com/mongodb-shell/
test> db.adminCommand({listDatabases: 1})
{
databases: [
{ name: 'admin', sizeOnDisk: Long('135168'), empty: false },
{ name: 'config', sizeOnDisk: Long('110592'), empty: false },
{ name: 'local', sizeOnDisk: Long('73728'), empty: false }
],
totalSize: Long('319488'),
totalSizeMb: Long('0'),
ok: 1
}
Congratulations — you now have a running deployment of the latest version of MongoDB on your Raspberry Pi. Want to use time-series and clustered collections for your home IoT project? We got ya. Want to keep your data secure using state-of-the-art queryable encryption? We got ya too. So go, have fun, create something amazing, and tell us about it in the comments.
Top comments (1)
Although unofficial, I had to add a shout out to the Raspberry Pi 4B binaries maintained by fellow MongoDB employee @themattman at this repo. Whatever shortcomings exist for the unsupported V8.0 ARM architecture, they seem to be minimal enough to skate for an awesome MondogDB time-series experience for home LAN embedded projects, even with the old RP 4B. Very much appreciate you MongoDB employees keeping the rest of us Pi Heads hooked up with the resources to make things awesome!
Some comments may only be visible to logged-in visitors. Sign in to view all comments.