Jak zbudować dedykowany, bezpieczny i minimalistyczny system Ubuntu na swoją malinę?

Ubuntu Core to zupełnie inne podejście do systemów embedded niż klasyczne dystrybucje, a nawet narzędzia typu Buildroot czy Yocto Project. Cały system opiera się tu na kontenerach snap. Każdy element – od kernela, przez sterowniki (gadget snap), aż po aplikacje użytkownika – jest odizolowanym kontenerem, z własnymi zależnościami i separacją od reszty systemu.

Brzmi skomplikowanie? Na początku może się takie wydawać. System budowania opiera się na tzw. modelach i wymaga przejścia przez proces podpisywania.

W poprzednim wpisie omówiliśmy podstawy ubuntu core i ogólnej architektury. Wpis znajdziesz TUTAJ

Postanowiłem stworzyć ten praktyczny poradnik, który bezboleśnie przeprowadzi Cię przez cały proces – od czystego pliku konfiguracyjnego do działającego systemu z zainstalowaną aplikacją Node-RED.

Co będzie potrzebne?

Zanim zaczniemy, przygotujmy niezbędne narzędzia. Po stronie komputera, na którym pracujemy (hosta) potrzebujemy:

• Konto Ubuntu One – niezbędne do uwierzytelnienia obrazu i przypisania kluczy SSH. Bez tego system nie pozwoli nam się zalogować. Możesz je założyć za darmo pod tym linkiem.

• System Ubuntu w wersji 22.04 LTS lub nowszej.

• Czytnik kart pamięci microSD.

• Przynajmniej 10 GB wolnego miejsca na dysku.

Po stronie sprzętu docelowego (targetu):

• Raspberry Pi 4 Model B.

• Karta microSD o pojemności minimum 4 GB.

• Klawiatura i monitor (będą potrzebne tylko podczas pierwszego rozruchu do wstępnej konfiguracji).

• Połączenie sieciowe – kabel Ethernet lub sieć Wi-Fi.

Plan działania

Całość obejmuje kilka kroków, które szczególnie przy pierwszym spotkaniu z Ubuntu Core mogą być trochę skomplikowane. System budowania różni się wyraźnie od tego co znamy z Buildroota czy Yocto Project.

Musimy po kolei:

– uwierzytelnić się w systemie Ubuntu One dla snapcrafta

– ściągnąć i zmodyfikować model

– podpisać model

– zbudować obraz

– zaflashować obraz na kartę SD i dokonać pierwszej konfiguracji

Krok 1: Uwierzytelnianie

Aby budować własne obrazy i pobierać snapy ze sklepu Canonical, musimy zalogować się w terminalu danymi naszego konta Ubuntu. To obowiązkowy krok – bez tego daleko nie zajdziemy.

Po utworzeniu konta w przeglądarce, wracamy do terminala na hoście i eksportujemy dane uwierzytelniające, z których skorzysta narzędzie snapcraft:

 Krok 2: Tworzenie model assertion

Budowanie obrazu opiera się na pliku konfiguracyjnym w formacie JSON, zwanym modelem. Definiuje on dokładnie, co budujemy, kto jest wydawcą (tu wstawimy nasze ID) oraz jakie komponenty (snapy) mają wejść w skład gotowego obrazu. W przeciwieństwie do klasycznego Ubuntu, wersja Core jest ekstremalnie odchudzona i pozbawiona większości systemowego bloatu.

Tworzymy katalog roboczy i pobieramy oficjalny, bazowy model dla Raspberry Pi 4 pod Ubuntu Core 26:

Otwieramy plik my-model.json w ulubionym edytorze tekstowym. Musimy zmodyfikować następujące pola:

Zastępujemy wartość "canonical" naszym własnym ID, które wyciągnęliśmy przed chwilą z komendy snapcraft whoami.

Dodajemy Node-RED

Aby nasz obraz nie był tylko pustą konsolą, dorzucimy do niego od razu ciekawe narzędzie – Node-RED.

Czym jest Node-RED? To popularna platforma do programowania wizualnego (flow-based programming), stworzona z myślą o IoT i automatyzacji. Zamiast pisać setki linii kodu, aplikacje tworzy się w niej poprzez przeciąganie gotowych klocków (nodów) i łączenie ich ze sobą w przeglądarce. Jest lekka, bardzo intuicyjna i pozwala na błyskawiczne prototypowanie integracji smart home, czujników czy zewnętrznych API.

Aby dodać Node-RED do naszego obrazu, musimy najpierw poznać jego identyfikator (snap-id) w sklepie Snap Store:

Dodajemy nowy wpis do tablicy snaps w naszym modelu (pamiętaj o dodaniu przecinka po poprzednim obiekcie!):

Snapy z założenia nie mają zewnętrznych zależności – wszystko dostajemy zapakowane w jedno bezpieczne „pudełko”. Istnieje jednak drobny wyjątek. Aplikacje potrzebują tzw. base snapa (czyli bazowego systemu operacyjnego z podstawowymi bibliotekami systemowymi). Nasz model korzysta z nowej bazy core26, ale aplikacja Node-RED została skompilowana pod starszą wersję.

Sprawdźmy, jakiej bazy wymaga:

Oznacza to, że musimy dodać do pliku modelu również bazę core22. Pobieramy jej snap-id (za pomocą snap info core22) i dopisujemy kolejny element do tablicy snaps:

UWAGA: Bardzo ważny krok! W definicji modelu, przy pozycji console-conf, domyślnie znajduje się linijka "presence": "optional". Musimy ją usunąć. console-conf to interfejs konfiguracyjny, który wita nas przy pierwszym uruchomieniu i pozwala na powiązanie urządzenia z naszym kontem. Bez niego system nie pozwoli nam się poprawnie zalogować.

Ostateczna, kompletna wersja pliku my-model.json powinna wyglądać następująco:

Krok 3: Podpisanie modelu

Model w postaci czystego JSONa nie może jeszcze posłużyć do zbudowania systemu. Musimy go podpisać naszym kluczem deweloperskim, tworząc tzw. model assertion. Dzięki temu system Ubuntu Core wie, że nikt nie majstrował przy konfiguracji obrazu i pochodzi on ze znanego, zaufanego źródła.

Uwaga: Aby operacje na kluczach przebiegły pomyślnie, zaloguj się wcześniej na portalu snapcraft.io za pomocą swojego konta i zaakceptuj warunki umowy programistycznej (Developer Agreement).

Sprawdzamy obecne klucze w systemie:

I upewniamy się, czy klucz jest gotowy do pracy:

Zanim podpiszemy plik, musimy zaktualizować pole timestamp w naszym pliku my-model.json na aktualny czas UTC. Szybko sprawdzimy go w terminalu:

W ten sposób powstał plik my-model.model zawierający podpisany model assertion.

Krok 4: Budowanie obrazu

Do właściwego złożenia obrazu posłuży nam narzędzie ubuntu-image. Instalujemy je na komputerze:

sudo snap install ubuntu-image –classic –edge

Następnie budujemy nasz obraz za pomocą ubuntu-image na bazie model assertion.

ubuntu-image snap –allow-snapd-kernel-mismatch my-model.model

Narzędzie pobierze z serwerów wszystkie wymagane snapy i skompiluje obraz systemu w zaledwie kilka minut. Na koniec otrzymamy plik pi.img o rozmiarze około 500 MiB.

Możemy go teraz wgrać na kartę microSD przy użyciu popularnego narzędzia Raspberry Pi Imager (wybierając opcję „Własny obraz” / „Custom .img”).

Zanim jednak włożymy kartę do maliny, warto rzucić okiem na jej strukturę plików po wgraniu systemu:

Znajdziemy tu sporo standardowych plików firmware od Raspberry Pi Foundation (pliki fixup*, start*, bootcode.bin), które w większości są closed-source i odpowiadają za uruchomienie procesora. Najciekawszy jest jednak katalog snaps/ – to właśnie tam leżą spakowane archiwa z naszymi programami (w tym Node-RED), które zostaną rozpakowane i uruchomione podczas pierwszego startu systemu.

Krok 5: Pierwsze uruchomienie

Wkładamy kartę do Raspberry Pi, podłączamy zasilanie, monitor, klawiaturę oraz (opcjonalnie) konwerter USB-UART. Po chwili na ekranie pojawi się komunikat:

Press enter to configure.

Naciskamy Enter. System może na chwilę złapać lekkiego „laga”, gdy konfiguruje w tle mechanizmy bezpieczeństwa, ale po chwili poprosi nas o podanie adresu e-mail. Uwaga: musimy podać ten sam e-mail, który jest powiązany z naszym kontem Ubuntu One!

Po wpisaniu maila i zatwierdzeniu klawiszem Enter, system pobierze z serwerów nasze klucze publiczne SSH i dokona ostatecznej inicjalizacji.

W tym momencie kończy się jakakolwiek interakcja lokalna (czy przez UART) z systemem. Ubuntu Core został zaprojektowany z myślą o najwyższym poziomie bezpieczeństwa, dlatego tradycyjna konsola tekstowa logowania z hasłem jest wyłączona. Jedynym sposobem na dostanie się do terminala jest bezpieczne połączenie SSH autoryzowane naszym kluczem publicznym.

Urządzenie wyświetli nam instrukcję połączenia na ekranie:

Po zalogowaniu wita nas upragniony prompt systemowy:

Możemy łatwo zweryfikować, czy wszystkie snapy zainstalowały się pomyślnie i czy nasza aplikacja działa:

Wszystko jest na swoim miejscu! Node-RED działa w tle. Żeby to ostatecznie potwierdzić, otwieramy przeglądarkę na komputerze deweloperskim i wpisujemy adres IP naszej malinki wraz z domyślnym portem Node-RED:

http://<adres_ip_raspberry>:1880

Naszym oczom ukaże się w pełni funkcjonalny edytor graficzny. Sprawdziłem również instalację dodatkowych rozszerzeń (w tym Node-RED Dashboard do tworzenia graficznych interfejsów użytkownika) – instalacja dodatków przebiegła bez jakichkolwiek problemów.

W ten sposób stworzyliśmy stabilną, bezpieczną i niezwykle lekką platformę IoT, która jest w pełni gotowa na wdrożenie Twoich automatyzacji i projektów embedded!

Podsumowanie

Przejście przez cały proces budowania Ubuntu Core po raz pierwszy może wydawać się skomplikowane, ale w rzeczywistości to bardzo logiczna i powtarzalna ścieżka. W tym poradniku krok po kroku:

• Zalogowaliśmy się i uwierzytelniliśmy w systemie Canonical za pomocą narzędzia snapcraft, aby powiązać proces budowania z naszym unikalnym kontem.

• Stworzyliśmy definicję modelu na bazie oficjalnego szablonu JSON dla Raspberry Pi 4, do którego dodaliśmy aplikację Node-RED wraz z wymaganym przez nią środowiskiem uruchomieniowym core22.

• Wygenerowaliśmy i zarejestrowaliśmy klucz GPG, którym podpisaliśmy nasz model, tworząc plik konfiguracyjny model assertion.

• Skompilowaliśmy gotowy obraz systemu przy użyciu narzędzia ubuntu-image i wgraliśmy go na kartę microSD.

• Uruchomiliśmy system na Raspberry Pi, przechodząc przez wstępną konfigurację sieciową i powiązanie z kontem Ubuntu One, co pozwoliło na automatyczne pobranie naszych kluczy publicznych SSH.

• Przetestowaliśmy działanie systemu, logując się bezpiecznie przez SSH oraz uruchamiając graficzny edytor Node-RED bezpośrednio z poziomu przeglądarki na hoście.

Teraz masz spersonalizowany, bezpieczny i minimalistyczny system operacyjny gotowy do działania. Ubuntu core nie jest pozbawiony wad, ale może być ciekawą alternatywą dla projektów zbudowanych na bazie Yocto lub Buildroota.