Print server¶

Exercise print-server-annex.pdf · PDF

Twelve people, one printer, 13:55 on a Friday. Everybody prints in the same minute. Why don't the pages of twelve documents come out mixed together?

Because the documents wait in order, and somebody keeps that order. And when one 300-page document blocks everybody else, somebody must be able to take it out. That somebody is a service on the server, and on this page you install it, share it, and drive its queue by hand.

One printer, twelve people: the queue¶

Think of the ticket machine at the bakery counter. Each customer takes a number and waits; the baker serves them in order. Nobody pushes, and if someone with a huge order is holding everybody up, the manager can move them aside.

• A document sent to print is a job (a customer with a ticket).
• Jobs wait in a queue (the line of numbers).
• The program that keeps the queue and feeds the printer is the spooler (the baker who calls the next number).

There are three ways to reach a printer:

A print server is a service that receives print jobs from the clients, keeps them in a queue and sends them to the printer.

flowchart LR
    C1["<b>deb-lab</b>"] -->|"job"| Q
    C2["<b>win11</b>"] -->|"job"| Q
    C3["<b>marta's laptop</b>"] -->|"job"| Q
    subgraph SRV ["ubu-srv: the print server"]
        Q["<b>queue office-pdf</b><br>jobs wait in order<br>(the bakery tickets)"]
    end
    Q -->|"one job at a time"| P["<b>Printer</b><br>today: a PDF file"]

CUPS and IPP¶

On Linux and macOS the spooler is CUPS. Michael Sweet started writing it in 1997 at his small company, Easy Software Products; the first public beta came out on 14 May 1999. Apple adopted it for macOS in 2002 and bought it in 2007; today the OpenPrinting project maintains it.

CUPS speaks IPP, the Internet Printing Protocol, on TCP port 631. So do modern printers themselves, which is why a new printer usually works with no driver at all.

Today's printer is virtual: a queue that turns every job into a PDF file. Everything is the same as with paper except the last metre.

Install CUPS on the server¶

sudo apt install cups printer-driver-cups-pdf
lpstat -r
sudo ss -tlnp | grep 631

lpstat -r should say scheduler is running. Now look at the ss line: CUPS listens on 127.0.0.1:631 and [::1]:631, localhost only. Remember Clients, servers and shared resources: right now deb-lab cannot reach it.

The installation may already create a queue called PDF. That is harmless; you will make your own.

Create a queue and print¶

One command in three lines (the \ at the end of a line means "it continues"):

sudo lpadmin -p office-pdf -E -v cups-pdf:/ \
  -m lsb/usr/cups-pdf/CUPS-PDF_opt.ppd \
  -D "Tramuntana office printer" -L "Palma office"

CUPS answers with an honest warning: Printer drivers are deprecated and will stop working in a future version of CUPS. Drivers are on their way out because of IPP; our PDF printer still needs one.

$ sudo lpadmin -d office-pdf
$ lpstat -p -d
printer office-pdf is idle.  enabled since Mon Oct  5 21:01:03 2026
system default destination: office-pdf
$ echo "Invoice 2027-041" > invoice.txt
$ lp invoice.txt
request id is office-pdf-1 (1 file(s))

lpadmin -d makes it the default queue; lp sends a job, and CUPS gives it a request id: the bakery ticket. The PDF appears in ~/PDF/ of the user who printed.

Share the queue¶

sudo cupsctl --share-printers
sudo lpadmin -p office-pdf -o printer-is-shared=true
sudo ss -tlnp | grep 631

Now CUPS listens on every address (0.0.0.0:631 or *:631). cupsctl rewrote /etc/cups/cupsd.conf for you: Listen localhost:631 became Port 631, and machines of the local network were allowed. It does not open the printer to the whole Internet, and the router's firewall is still there.

Print from the client¶

On deb-lab (if lp is missing, install cups-client):

$ lpstat -h ubu-srv -p -d
printer office-pdf is idle.  enabled since Mon Oct  5 20:55:59 2026
system default destination: office-pdf
$ echo "hello from deb-lab" > hello.txt
$ lp -h ubu-srv -d office-pdf hello.txt
request id is office-pdf-2 (1 file(s))

-h ubu-srv means "ask the CUPS of that host". Where is the PDF? On the server: in ~/PDF/ if a user with the same name exists there, otherwise in /var/spool/cups-pdf/ANONYMOUS/. With paper, it would come out of the printer; the client keeps nothing.

GNOME on deb-lab may even show office-pdf in Settings → Printers by itself: shared CUPS queues announce themselves on the local network.

Manage the queue¶

Pause the queue on the server, send three jobs from the client, and look:

sudo cupsdisable office-pdf                                       # server
for i in 1 2 3; do lp -h ubu-srv -d office-pdf hello.txt; done    # client
lpstat -o                                                         # server

$ lpstat -p
printer office-pdf disabled since Mon Oct  5 21:01:03 2026 -
    Paused
$ lpstat -o
office-pdf-1            marta             1024   Mon Oct  5 21:01:03 2026
office-pdf-3            root              1024   Mon Oct  5 21:01:03 2026

A paused queue still accepts jobs: it only stops sending them to the printer. Each line of lpstat -o is a waiting job: its id, who sent it, its size and when. Cancel one, then restart the queue:

sudo cancel office-pdf-N
sudo cupsenable office-pdf
lpstat -o
lpstat -W completed -o

The waiting jobs come out in order, and lpstat -W completed -o lists the finished ones. The cancelled job never becomes a PDF.

Key takeaways¶

• A print server gives one queue, one place for permissions and one log for a shared printer.
• A job waits in a queue; the spooler feeds the printer. On Linux and macOS it is CUPS (Michael Sweet, 1997–1999).
• CUPS speaks IPP on TCP 631; modern printers speak IPP too, so they often need no driver.
• lpadmin creates a queue, cupsctl --share-printers opens it to the local network (by default it is localhost only), lp -h server prints from a client.
• A paused queue keeps accepting jobs. Check the queue with lpstat before blaming the printer.

Quick check¶

Count what is on your server now: SSH, Samba, NFS, CUPS, four services side by side, sharing the same system. What if two of them need different versions of the same library? Next, each service gets its own sealed box: Containers.