Dear Orcada Delegators and Cardano Community,

We were recently notified that our Twitter account (@Orcada_io) has been suspended.

We do not know why our account was suspended, however, we have submitted an appeal to the Twitter support team requesting that they reinstate our account.

We are yet to receive a response.

In the meantime, please join us on our Telegram group where we are available 24/7 to answer any questions you may have.

Many thanks,
The Orcada Team

The HoneyComb LX2 is an ARM SBC with 16 cores and support for up to 64GB of memory.

The HoneyComb LX2 is ARM SystemReady ES certified, which means any off the shelf Linux distribution should boot and basic hardware functionality will "just work".

Prerequisites

• 1 @ HoneyComb LX2
• 1 @ Silicon Power 64GB (2 x 32GB) SO-DIMM DDR4 3200MHz (must be a matched pair)
• 1 @ Samsung 2TB 970 EVO Plus NVMe SSD
• 1 @ Linksys USB 3 Gigabit Ethernet Adapter
• 1 @ Cable Matters Micro USB to USB-C cable
• 1 @ SanDisk 32GB Micro SD card
• 1 @ SanDisk 32GB Flash Drive

Getting Started

Rackmount

I wanted to rack mount the LX2, so I purchased a 1U Mini-ITX form factor rackmount case from the Mini ITX Store:

I mounted the board and then installed the RAM and the NVMe SSD. I attached the dual 24/20 (sometimes called 20+4) power supply connector to the ATX 24-pin motherboard socket. The fan to the fan PWM socket and the front panel connector ribbon to the board's front panel connectors.

Firmware

I used the balenaEtcher to flash a firmware image (i.e., lx2160acex7_2000_700_3200_8_5_2_sd_ee5c233.img.xz) to the micro SD card.

Note: You must use the firmware image that matches the clock speed (e.g., 3200 MHz) of your DDR4 RAM.

Linux distribution

I used the balenaEtcher to flash a Debian 11.5 ISO image (i.e., debian-11.5.0-arm64-netinst.iso) to the USB 3 flash drive.

First boot

Connect the USB 3 ethernet adapter to your switch (or router). Insert the Micro SD card and the USB 3 flash drive.

Serial connection

Connect the micro USB to the LX2 and the USB-C cable to your workstation.

Look for the device:

ls -l /dev/*usbserial*

You should see something like:

crw-rw-rw-  1 root  wheel  0x9000005 15 Oct 18:06 /dev/cu.usbserial-DK0D18XC
crw-rw-rw-  1 root  wheel  0x9000004 15 Oct 18:06 /dev/tty.usbserial-DK0D18XC

Use screen to open a connection:

screen /dev/tty.usbserial-DK0D18XC 115200

Power on the server.

Press the esc key when prompted by the UEFI firmware:

Navigate to the Device Manager -> Console Preference Selection and set the Preferred console to Serial:

Navigate to the Boot Manager and choose USB SanDisk:

Hit esc to launch GRUB:

Press e to edit the Install command:

And update it as follows:

arm-smmu.disable_bypass=0 \
iommu.passthrough=1 \
console=ttyAMA0,115200n8 ---

Press Ctrl-x to launch the Debian installer.

After the installation is complete power off the server, remove the USB Flash Drive and then power on the server.

Login:

How to upgrade the Linux kernel

The easiest way to upgrade the kernel is to use the backports repository.

Create a sources list for DebianBackports:

sudo nano /etc/apt/sources.list.d/backports.list

And update it as follows:

deb http://deb.debian.org/debian bullseye-backports main

Then save (Ctrl+O) and exit (Ctrl+X) nano.

Download the package index from the backports repository:

sudo apt update

Install the kernel package from the backports repository:

sudo apt install linux-image-arm64/bullseye-backports

Check the version:

uname -s -v

You should see something like:

Linux #1 SMP Debian 5.18.16-1~bpo11+1 (2022-08-12)

The updated kernel has driver support for the LX2's gigabit ethernet adapter.

Afterword

Unfortunately, there are some known issues with the ASIX chip drivers (generally used by USB 3 gigabit ethernet adapters) included in off the shelf (mainline) Linux distributions.

• Kernel.org Bugzilla – Bug 212731: USB 3 gigabit ethernet adapter ASIX AX88179

Resources:

• SolidRun wiki: Serial Connection Guide
• Discord: SolidRun channel
• Debian GNU/Linux Installation Guide: Console configuration

The Tailwind CSS framework is a utility-first CSS framework designed to help you rapidly build modern websites.

Prerequisites

• Node.js

Getting Started

Step 1: Install the Command Line Interface

I installed the Tailwind CSS CLI globally using npm:

npm install -g tailwindcss

You can check your installation by running the following command:

tailwindcss -h

You should see something like:

tailwindcss v3.1.8

Usage:
   tailwindcss [--input input.css] [--output output.css] [--watch] [options...]
   tailwindcss init [--full] [--postcss] [options...]

Commands:
   init [options]

Options:
   -i, --input              Input file
   -o, --output             Output file
   -w, --watch              Watch for changes and rebuild as needed
   -p, --poll               Use polling instead of filesystem events when watching
       --content            Content paths to use for removing unused classes
       --postcss            Load custom PostCSS configuration
   -m, --minify             Minify the output
   -c, --config             Path to a custom config file
       --no-autoprefixer    Disable autoprefixer
   -h, --help               Display usage information

Step 2: Create a workspace

To create a new workspace:

mkdir tailwind-css
cd tailwind-css

Step 3: Create a project folder

To create a project folder:

mkdir website
cd website

Use npm init to initialise the project:

npm init

Step 3: Install the Tailwind CSS framework

To install the Tailwind CSS framework:

npm install --save-dev tailwindcss

Create the tailwind.config.js file:

tailwindcss init

Step 4: Create an index.html file

Create an index.html file:

mkdir public
cd public
nano index.html

And update it as follows:

<!DOCTYPE HTML>
<html lang="en">

  <head>

    <meta charset="utf-8" />

    <link href="./assets/images/favicon.ico" rel="icon" type="image/x-icon" />

    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no" />

    <title>Tailwind CSS | Starter Project</title>
    <meta name="description" content="A Tailwind CSS Starter Project." />
    <meta name="keywords" content="Tailwind CSS"/>

    <link href="./styles.css" rel="stylesheet" />

  </head>

  <body>
  
    <!-- Place content (blocks) here -->

  </body>

</html>

Step 5: Create a styles.css file

Create an styles.css file:

mkdir src
cd src
nano styles.css

Add the @tailwind directives to the styles.css file:

@tailwind base;
@tailwind components;
@tailwind utilities;

Step 6: Update the tailwind.config.js file

Update the tailwind.config.js file:

const colors = require('tailwindcss/colors')

module.exports = {
  content: [
    "./public/*.html"
  ],
  theme: {
    colors: {
      primary: colors.blue
    }
  },
  plugins: []
}

Your project should now look something like:

.
└── website
    ├── package.json
    ├── public
    │   ├── assets
    │   │   ├── images
    │   │   │   ├── favicon.ico
    │   │   │   └── orcada-logo.png
    │   │   └── js
    │   │       └── flowbite.js
    │   ├── index.html
    │   └── styles.css
    ├── src
    │   └── styles.css
    └── tailwind.config.js

Step 7: Start the Tailwind CLI build process

tailwindcss -i ./src/styles.css -o ./public/styles.css --watch

Preview your website:

Flowbite

If you are looking for inspiration then you take a look at Flowbite.

It is designed to make building Tailwind CSS websites even faster.

To install Flowbite:

npm install --save-prod flowbite
npm install --save-dev flowbite-typography

Update the tailwind.config.js file:

const colors = require('tailwindcss/colors')

module.exports = {
  content: [
    "./public/*.html",
    "./assets/js/*.js"
  ],
  darkMode: 'class',
  theme: {
    colors: {
      primary: colors.blue,
      secondary: colors.gray,
      'brand': {
        blue: '#00aeef',
        DEFAULT: '#00aeef',
        lightblue: '#8ed1fc',
      },
    }
  },
  plugins: [
    require('flowbite/plugin'),
    require('flowbite-typography')
  ]
}

And update the index.html file to include flowbite.js:

<!DOCTYPE HTML>
<html lang="en">

  <head>

    ...

  </head>

  <body>
  
    <!-- Place content (blocks) here -->
 
    <script src="./assets/js/flowbite.js"></script>

  </body>

</html>

Resources:

• GitHub: Tailwind CCS Starter Project

In this post, we'll configure a Raspberry Pi (RPi) 4 Model B to PXE Boot from a Synology Diskstation DS720+.

What is PXE Boot?

The Preboot eXecution Environment (PXE) specification describes a standardised client–server environment that boots a software assembly, retrieved from a network, on PXE-enabled clients. - Wikipedia

Clients require a network interface controller (NIC) and utilise DHCP and TFTP.

In data centres, PXE is the most popular choice for operating system booting, installation and deployment.

Synology NAS

The Synology Diskstation DS720+ is running DSM 7.0.1 (DSM 7.0.1-42218 Update 3).

What we need to do:

• Configure a Static IP
• Enable NFS
• Create some Shared Folders
• Edit the Shared Folders NFS permissions
• Enable TFTP
• Install and configure a DHCP Server
• Enable PXE Boot

Note: The Synology Disk Station Manager (DSM) screenshots included in this guide were produced using DSM version 7.0.1 (DSM 7.0.1-42218 Update 3).

Configure a Static IP

In the DSM's Control Panel, click on Network and then select the Network Interface tab:

Manual configuration:

Enable NFS

In the Control Panel, click on File Services and then select the NFS tab:

Create Shared Folders

We need to create some shared folders for the RPi's Boot and OS files:

• rpi-pxe (used for the RPi's OS files)
• rpi-tftpboot (used for the RPi's Boot files)

In the Control Panel, click on Shared Folder:

General configuration, rpi-pxe:

General configuration, rpi-tftpboot:

And then for each folder (rpi-pxe and rpi-tftpboot) edit the NFS permissions:

Enable TFTP

In the Control Panel, click on File Services and then select the Advanced tab:

DHCP Server

Use the DSM's Package Center to install a DHCP Server. In the DSM's Main Menu click on DHCP Server.

And then for each Network Interface (LAN 1 and LAN 2) enable the DHCP server:

We also need to configure the Subnet list:

And the Vendor Settings:

There is one more configuration step we need to complete on the DHCP Server, however, we can't do that until we have setup our RPi.

Raspberry Pi

Raspberry Pi Imager

Download and launch the Raspberry Pi Imager.

Use the Imager to create a fresh install of Raspberry Pi OS Lite 64 bit (a port of Debian Bullseye with no Desktop environment). Use the Advanced options to: set a hostname (relay-node-1); enable SSH (public key only), set a username and password; set the locale settings and to skip the first-run wizard.

Note: You can use a fully qualified domain name (FQDN), for example: relay-node-1.stake-pool.orcada.io

Insert the Micro SD Card into the Raspberry Pi and power on the device. Use the DHCP Server's DCHP Clients tab to find the RPi's (dynamic) IP address.

You can also use nmap, for example:

sudo nmap -sn 192.168.101.0/24

Use SSH to connect to the device and update the operating system:

sudo apt update
sudo apt full-upgrade -y
sudo apt-get autoremove
sudo apt-get autoclean

Configure a Static IP

The Raspberry Pi OS uses dhcpcd to configure TCP/IP across all of its network interfaces. We want to assign a static IP to our RPi.

Edit the /etc/dhcpcd.conffile:

sudo nano /etc/dhcpcd.conf

And add the following lines to the bottom of the file:

...

# relay-node-1
interface eth0
static ip_address=192.168.101.3/24
static routers=192.168.101.1
static domain_name_servers=192.168.101.1

To restart dhcpcd:

sudo systemctl daemon-reload && sudo systemctl restart dhcpcd

Let's check the Domain Name System (DNS) resolver:

cat /etc/resolv.conf

You should see something like:

# Generated by resolvconf
nameserver 192.168.101.1

Configure the hostname

To configure a fully qualified domain name (FQDN) we need to edit the /etc/hostname file:

sudo nano /etc/hostname

And update it as follows:

relay-node-1.stake-pool.orcada.io

We also need to edit the /etc/hosts file:

sudo nano /etc/hosts

And update it as follows:

127.0.0.1       localhost
192.168.101.3   relay-node-1.stake-pool.orcada.io relay-node-1

# IPv6
::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

Reboot the RPi:

sudo reboot

Reconnect to the device using SSH.

Copy the OS files to the rpi-pxe Shared Folder

Create the remote mount point

Connect (SSH) to the Synology NAS, you should see something like:

admin@nas-1:~$

Create a directory in the rpi-pxe shared folder, that matches the RPi's hostname:

cd /volume1/rpi-pxe
sudo mkdir relay-node-1

And update the permissions:

sudo chmod 777 relay-node-1

Note: You can check your RPi's hostname using the following command:

hostname

Create the local mount point

Create a local mount point (directory) that matches the RPi's hostname:

sudo mkdir -p /nfs/relay-node-1

Mount the rpi-pxe shared folder (the remote mount point) with NFS:

sudo mount -t nfs -O proto=tcp,port=2049,rw,all_squash,anonuid=1001,anongid=1001 192.168.101.2:/volume1/rpi-pxe/relay-node-1 /nfs/relay-node-1 -vvv

Copy the OS files (it will take a few minutes):

sudo rsync -xa --progress --exclude /nfs / /nfs/relay-node-1/

Copy the Boot files to the rpi-tftpboot Shared Folder

Create the local mount point

Create a local mount point (directory):

sudo mkdir -p /nfs/rpi-tftpboot

Mount the rpi-tftpboot shared folder (the remote mount point) with NFS:

sudo mount -t nfs -O proto=tcp,port=2049,rw,all_squash,anonuid=1001,anongid=1001 192.168.101.2:/volume1/rpi-tftpboot /nfs/rpi-tftpboot -vvv

After mounting the rpi-tftpboot shared folder, the next step is to copy the universal RPi bootcode.bin file to the root of the rpi-tftpboot shared folder. The bootcode.bin
file is used by all RPi models and must be in the root of this shared folder for PXE Boot to succeed:

sudo cp /boot/bootcode.bin /nfs/rpi-tftpboot/

Get the RPi's serial number:

vcgencmd otp_dump | grep 28: | sed s/.*://g

You should see something like:

d7cde1e3

Create a directory for the boot files, that matches the RPi's serial number:

sudo mkdir -p /nfs/rpi-tftpboot/d7cde1e3

Copy the boot files:

sudo cp -r /boot/* /nfs/rpi-tftpboot/d7cde1e3/

Configure the Boot options

Edit /etc/fstab (the filesystem table) so that it mounts the RPi's tftpboot directory when it starts up:

sudo nano /nfs/relay-node-1/etc/fstab

Update it as follows:

proc            /proc           proc    defaults          0       0
192.168.101.2:/volume1/rpi-tftpboot/d7cde1e3 /boot nfs defaults,vers=3,proto=tcp 0 0

Edit the kernel options in cmdline.txt:

sudo nano /nfs/rpi-tftpboot/d7cde1e3/cmdline.txt

Update it as follows:

console=serial0,115200 console=tty1 root=/dev/nfs nfsroot=192.168.101.2:/volume1/rpi-pxe/relay-node-1,vers=3 rw ip=dhcp elevator=deadline rootwait

Configure the EEPROM firmware

We need to configure the RPi's eeprom firmware to include the PXE boot options.

Use the following command to identify the latest version of the firmware:

ls -al /lib/firmware/raspberrypi/bootloader/stable/

Copy the latest version of the firmware to a temporary directory in your home directory:

sudo cp /lib/firmware/raspberrypi/bootloader/stable/pieeprom-2022-03-10.bin pieeprom.bin

Create a boot configuration file:

sudo nano bootconf.txt

Update it as follows:

[all]
BOOT_UART=0
WAKE_ON_GPIO=1
POWER_OFF_ON_HALT=0
DHCP_TIMEOUT=45000
DHCP_REQ_TIMEOUT=4000
TFTP_FILE_TIMEOUT=30000
TFTP_IP=192.168.101.2
TFTP_PREFIX=0
ENABLE_SELF_UPDATE=1
DISABLE_HDMI=0
BOOT_ORDER=0x241
SD_CARD_MAX_RETRIES=3
NET_BOOT_MAX_RETRIES=5

The RPi will try to boot from a microSD card, then the network, then from any attached USB storage.

Now we can create a new EEPROM binary:

sudo rpi-eeprom-config --out pieeprom-new.bin --config bootconf.txt pieeprom.bin

And write it to the EEPROM:

sudo rpi-eeprom-update -d -f ./pieeprom-new.bin

Reboot (leave the microSD card inserted):

sudo reboot

Check the new boot configuration values using the following command:

vcgencmd bootloader_config

Synology NAS

Enable PXE Boot

There is one more configuration step we need to complete on the DHCP Server, and that is to enable PXE Boot:

Raspberry Pi

PXE Boot

Shutdown the RPi:

sudo shutdown -h now

Turn off the power, remove the microSD card, turn the power back on. The RPi should now PXE boot.

Connect (SSH) to the RPi and check the mounted filesytems:

findmnt

You should see something like:

Troubleshooting

If you run into any issues try plugging in a monitor:

A coloured splash screen (actually it's just four pixels "blown up" by the GPU to full screen) is displayed after the GPU firmware (start.elf) is loaded:

This should be replaced by the linux console a few seconds later:

Resources:

• Raspberry Pi forum: Troubleshooting
• eLinux wiki: Troubleshooting

References:

• Mike McFarlane's blog: PXE boot a Raspberry Pi 4 from a Synology Diskstation
• John Nicpon's (Warmest Robot) blog: Raspberry Pi Network Boot Guide
• Raspberry Pi docs: Configuration properties

Cardano GraphQL

As its name suggests the Cardano GraphQL project adds support for the GraphQL query language to the Cardano ecosystem.

Services

The Cardano GraphQL project includes the following services:

• PostgreSQL
• Cardano Node Ogmios
• Cardano DB Sync Extended
• Hasura
• Cardano GraphQL

Getting Started

The project includes an example docker-compose.yml. However, before you start it is important that you understand the interdependencies between each of the project's services.

For example, you need to sync the Cardano Node with the blockchain before you use Cardano DB Sync Extended to restore a snapshot (see: Cardano DB Sync rolling back to genesis).

docker-compose-cardano-node.yml:

version: "3.8"

services:
  cardano-node-ogmios:
    image: cardanosolutions/cardano-node-ogmios:${CARDANO_NODE_OGMIOS_VERSION:-v5.1.0}-${NETWORK:-mainnet}
    restart: on-failure
    container_name: cardano-node-ogmios
    ports:
      - ${OGMIOS_PORT:-1337}:1337
    volumes:
      - node-db:/db
      - node-ipc:/ipc
    logging:
      driver: "json-file"
      options:
        max-size: "400k"
        max-file: "20"

volumes:
  node-db:
  node-ipc:

Pull and run Cardano Node Ogmios:

export NETWORK=mainnet && \
docker-compose -f docker-compose-cardano-node.yml up -d

After 24 hours or so you can bring down the service:

docker-compose down

Tip: Cardano Node does not need to be at the tip of the blockchain it just needs to be past the last block in the snapshot (e.g., db-sync-snapshot-schema-12-block-6451499-x86_64.tgz) you want to restore. So keep an eye on the logs:

docker container logs -f --tail 10 cardano-node-ogmios

Now you are ready to pull and run all the Cardano GraphQL services and restore a snapshot:

export NETWORK=mainnet && \
export RESTORE_SNAPSHOT=/snapshots/db-sync-snapshot-schema-12-block-6451499-x86_64.tgz && \
docker-compose up -d

docker-compose.yml:

version: "3.8"

services:
  postgres:
    image: postgres:${POSTGRES_VERSION:-11.5-alpine}
    restart: on-failure
    container_name: postgres
    environment:
      - POSTGRES_LOGGING=true
      - POSTGRES_DB_FILE=/run/secrets/postgres_db
      - POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password
      - POSTGRES_USER_FILE=/run/secrets/postgres_user
    ports:
      - ${POSTGRES_PORT:-5432}:5432
    secrets:
      - postgres_db
      - postgres_password
      - postgres_user
    shm_size: '2gb'
    volumes:
      - postgres-data:/var/lib/postgresql/data
    logging:
      driver: "json-file"
      options:
        max-size: "200k"
        max-file: "10"
        
  cardano-node-ogmios:
    image: cardanosolutions/cardano-node-ogmios:${CARDANO_NODE_OGMIOS_VERSION:-v5.1.0}-${NETWORK:-mainnet}
    restart: on-failure
    container_name: cardano-node-ogmios
    ports:
      - ${OGMIOS_PORT:-1337}:1337
    volumes:
      - node-db:/db
      - node-ipc:/ipc
    logging:
      driver: "json-file"
      options:
        max-size: "400k"
        max-file: "20"

  cardano-db-sync-extended:
    working_dir: /var/lib/cdbsync
    image: inputoutput/cardano-db-sync:${CARDANO_DB_SYNC_VERSION:-12.0.0}
    command: [
      "--config", "/config/cardano-db-sync/config.json",
      "--socket-path", "/node-ipc/node.socket"
    ]
    restart: on-failure
    container_name: cardano-db-sync-extended
    environment:
      - EXTENDED=true
      - POSTGRES_HOST=postgres
      - POSTGRES_PORT=5432
      - RESTORE_SNAPSHOT=${RESTORE_SNAPSHOT:-}
      - RESTORE_RECREATE_DB=N
    secrets:
      - postgres_password
      - postgres_user
      - postgres_db
    volumes:
      - ./config/network/${NETWORK:-mainnet}:/config
      - db-sync-data:/var/lib/cdbsync
      - db-sync-tmp:/tmp
      - node-ipc:/node-ipc
      - ./snapshots:/snapshots
    logging:
      driver: "json-file"
      options:
        max-size: "200k"
        max-file: "10"
    depends_on:
      - cardano-node-ogmios
      - postgres

  hasura:
    image: inputoutput/cardano-graphql-hasura:${CARDANO_GRAPHQL_VERSION:-6.2.0}
    restart: on-failure
    container_name: hasura
    ports:
      - ${HASURA_PORT:-8090}:8080
    environment:
      - HASURA_GRAPHQL_ENABLE_CONSOLE=true
      - HASURA_GRAPHQL_CORS_DOMAIN=http://localhost:9695
    secrets:
      - postgres_db
      - postgres_password
      - postgres_user
    logging:
      driver: "json-file"
      options:
        max-size: "200k"
        max-file: "10"
    depends_on:
      - postgres

  cardano-graphql:
    build:
      context: ./services/cardano-graphql
      dockerfile: Dockerfile
    restart: on-failure
    container_name: cardano-graphql
    environment:
      - SLEEP=${SLEEP:-3600}
      - ALLOW_INTROSPECTION=true
      - CACHE_ENABLED=true
      - LOGGER_MIN_SEVERITY=${LOGGER_MIN_SEVERITY:-info}
      - PROMETHEUS_METRICS=true
      - TRACING=true
    expose:
      - ${API_PORT:-3100}
    ports:
      - ${API_PORT:-3100}:3100
    secrets:
      - postgres_db
      - postgres_password
      - postgres_user
    logging:
      driver: "json-file"
      options:
        max-size: "200k"
        max-file: "10"
    depends_on:
      - postgres

  prometheus:
    image: prom/prometheus:latest
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--web.enable-lifecycle'
    container_name: prometheus
    ports:
      - ${PROMETHEUS_PORT:-9090}:9090
    volumes:
      - ./prometheus:/etc/prometheus
      - prometheus-data:/var/lib/prometheus/data
    depends_on:
      - cardano-graphql

  grafana:
    image: grafana/grafana-oss:latest
    container_name: grafana
    ports:
      - ${GRAFANA_PORT:-3000}:3000
    volumes:
      - ./grafana/provisioning:/etc/grafana/provisioning
    depends_on:
      - prometheus

secrets:
  postgres_db:
    file: ./placeholder-secrets/postgres_db
  postgres_password:
    file: ./placeholder-secrets/postgres_password
  postgres_user:
    file: ./placeholder-secrets/postgres_user

volumes:
  db-sync-data:
  db-sync-tmp:
  node-db:
  node-ipc:
  postgres-data:
  prometheus-data:

Navigate to the GraphQL Playground: http://localhost:3100/graphql

Query the epoch dataset:

{ cardanoDbMeta { initialized syncPercentage }}

Wait for initialized to be true to ensure the epoch dataset is complete.

Query the full dataset:

{ cardano { tip { number slotNo epoch { number } } } }

Cardano GraphQL

I added an ENTRYPOINT to the cardano-graphql build so that it would wait (it might need to sleep for a hour or more depending on the size of the snapshot) for the snapshot to be restored before it tries to add any new (Hasura) views to PostgreSQL.

docker-entrypoint.sh

#!/bin/sh

# Abort on any error
set -e

sleep "$SLEEP"

# Run the main container command
exec "$@"

Dockerfile

FROM inputoutput/cardano-graphql:6.2.0-mainnet

COPY docker-entrypoint.sh docker-entrypoint.sh
RUN chmod +x ./docker-entrypoint.sh

ENTRYPOINT ["./docker-entrypoint.sh"]
CMD ["node", "index.js"]

Docker Desktop for Mac

When I first tried to restore a snapshot I paid close attention to the logs:

docker container logs -f --tail 10 cardano-db-sync-extended

I encountered the following issue:

psql:/tmp/db-sync-snapshot-hc6bN9lE7U/db-sync-snapshot-schema-12-block-6451499-x86_64.sql:238416086: ERROR:  could not extend file "base/16384/214298": No space left on device
HINT:  Check free disk space.

psql:/tmp/db-sync-snapshot-hc6bN9lE7U/db-sync-snapshot-schema-12-block-6451499-x86_64.sql:238416150: ERROR:  could not write block 35045 of temporary file: No space left on device
CONTEXT:  parallel worker

To address this issue I had to remove all containers, networks, images and volumes:

docker system prune --all

Remove the Docker.raw (see: ERROR: No space left on device) file:

sudo rm /Users/<user>/Library/Containers/com.docker.docker/Data/vms/0/data/Docker.raw

And increase the default Disk image size:

References:

• Cardano GraphQL GitHub Issues: Can't perform query while syncing
• Cardano DB Sync GitHub Issues: db-sync makes a rollback after using RESTORE_SNAPSHOT
• Cardano DB Sync GitHub Issues: cardano-db-sync rolling back to genesis
• Cardano Ouroboros Network GitHub Issues: Introduce a blocking version of MsgFindIntersection for a specific blockNo