Google is committed to advancing racial equity for Black communities. See how.

Pierwsze kroki z Happy and Weave

Szczęśliwy to narzędzie stworzone przez Nest Labs dla lekkiej orkiestracji symulowanych topologii sieci. Happy przydaje się do tworzenia i testowania domowych sieci IoT.

Z Happy możesz:

  • Testuj protokoły sieciowe i inne rozproszone programy wykonawcze na jednym komputerze deweloperskim z systemem Linux bez użycia sprzętu IoTT
  • Wykonywanie zautomatyzowanych testów funkcjonalnych w sieci
  • Uruchom wiele równoczesnych, równoległych sieci w tym samym systemie, aby poprawić przepustowość testowania

W tym Codelab, dowiesz się, jak zacząć z szczęśliwy, jak również podstaw Weave dla urządzeń Internetu przedmiotów. Realizacja Weave użyjesz jest OpenWeave , wersja open-source wydany przez Nest.

f6996428fb06dede.png

Czego się nauczysz

  • Jak zbudować Happy i OpenWeave
  • Jak ręcznie utworzyć symulowaną sieć IoT
  • Jak zarządzać niestandardowymi topologiami
  • Jak podłączyć symulowaną sieć Happy do Internetu?
  • Podstawy Splotu

Co będziesz potrzebował

  • Maszyna z Linuksem, fizyczna lub wirtualna
  • Klient Git lub cli
  • Python 2.7
  • Podstawowe zrozumienie koncepcji sieci i routingu

Zainstaluj toolchain i zależności

Aby zbudować Happy i Weave, upewnij się, że masz obsługiwany toolchain i zainstalowane wszystkie zależności.

$ sudo apt-get update
$ sudo apt-get install -y autotools-dev build-essential git lcov \
                           libdbus-1-dev libglib2.0-dev libssl-dev \
                           libudev-dev make python2.7 software-properties-common \
                           python-setuptools bridge-utils python-lockfile \
                           python-psutil
$ sudo apt-get install -y --force-yes gcc-arm-none-eabi
$ sudo apt-get update -qq

Pobierz kod źródłowy

Sklonuj repozytoria Happy i OpenWeave Git z wiersza poleceń:

$ cd ~
$ git clone https://github.com/openweave/happy.git
$ git clone https://github.com/openweave/openweave-core.git

Zainstaluj szczęśliwy

Z katalogu głównego Happy zainstaluj Happy:

$ cd ~/happy
$ make

Sprawdź szczęśliwą instalację Happy

Polecenia Happy powinny być teraz dostępne z wiersza poleceń:

$ happy-state
State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes

NODES      Name    Interface    Type                                          IPs

Zainstaluj OpenWeave

Z katalogu głównego OpenWeave zainstaluj OpenWeave:

$ cd ~/openweave-core
$ make -f Makefile-Standalone

Skonfiguruj Happy z OpenWeave

Aby używać OpenWeave z Happy, musisz poinformować Happy, gdzie znajduje się instalacja Weave. Zaktualizować konfigurację zadowolony ze ścieżką do /src/test-apps w ramach swojej budowie OpenWeave:

$ happy-configuration weave_path ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps

Potwierdź konfigurację:

$ happy-configuration
User Happy Configuration
        weave_path         ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps

Sprawdź instalację OpenWeave

Polecenia Weave potrzebne w tym ćwiczeniu z programowania są dostępne z wiersza poleceń:

$ weave-fabric-add -h

    weave-fabric-add creates a weave fabric.

    weave-fabric-add [-h --help] [-q --quiet] [-i --id <FABRIC_ID>]

    Example:
    $ weave-fabric-add 123456
        Creates a Weave Fabric with id 123456

    return:
        0    success
        1    fail

Jeśli pojawia się błąd weave-fabric-add: command not found , zaktualizuj PATH zmienną środowiskową ze ścieżką stosowanych na happy plików binarnych:

$ export PATH=$PATH:~/openweave-core/src/test-apps/happy/bin

Stwórzmy za pomocą Happy następującą topologię trzech węzłów.

a3295ee87fbd9764.png

Ta topologia jest przykładem prostej sieci domowej (HAN). W tej sieci HAN dwa węzły są połączone ze sobą w sieci Thread, a jeden z tych węzłów łączy się z trzecim przez Wi-Fi. Ten węzeł może być również podłączony do routera bezprzewodowego w domu, aby zapewnić łączność z Internetem dla całej sieci HAN. Więcej o tym później.

Najpierw utwórz trzy węzły:

$ happy-node-add 01ThreadNode
$ happy-node-add 02BorderRouter
$ happy-node-add 03WiFiNode

Upewnijmy się, że istnieją:

$ happy-node-list
01ThreadNode
02BorderRouter
03WiFiNode

Teraz stwórzmy kilka sieci:

$ happy-network-add ThreadNetwork thread
$ happy-network-add WiFiNetwork wifi

Sprawdź, czy sieci istnieją:

$ happy-network-list
ThreadNetwork
WiFiNetwork

Sprawdź stan Happy:

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes
  ThreadNetwork       thread      UP
    WiFiNetwork         wifi      UP

NODES      Name    Interface    Type                                          IPs
   01ThreadNode
 02BorderRouter
     03WiFiNode

Nie wystarczy tylko podnieść sieć — musimy dodać węzły do ​​sieci. Zgodnie z naszym diagramem topologii dodaj każdy węzeł do odpowiedniej sieci:

$ happy-node-join 01ThreadNode ThreadNetwork
$ happy-node-join 02BorderRouter ThreadNetwork
$ happy-node-join 02BorderRouter WiFiNetwork
$ happy-node-join 03WiFiNode WiFiNetwork

Zauważ, że 02BorderRouter dodano zarówno ThreadNetwork i WiFiNetwork . Dzieje się tak, ponieważ jako router graniczny w naszej sieci HAN węzeł ten łączy ze sobą dwie indywidualne sieci.

Sprawdź stan Happy. Interfejsy każdego węzła działają:

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes
  ThreadNetwork       thread      UP
    WiFiNetwork         wifi      UP

NODES      Name    Interface    Type                                          IPs
   01ThreadNode        wpan0  thread
 02BorderRouter        wpan0  thread
                       wlan0    wifi
     03WiFiNode        wlan0    wifi

Nasza topologia wygląda teraz tak:

2d054e6c4e54089c.png

Ostatnim krokiem w tworzeniu naszej sieci Happy jest przypisanie adresów IP do każdego interfejsu na każdym węźle. Określ prefiks IP dla sieci, a Happy automatycznie przypisze Ci adresy IP.

Ponieważ protokół Thread używa IPv6, dodaj prefiks IPv6 do sieci Thread:

$ happy-network-address ThreadNetwork 2001:db8:1:2::

Sprawdź stan Happy. Interfejsy wątków w każdym węźle wątków mają adresy IP:

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes
  ThreadNetwork       thread      UP                       2001:0db8:0001:0002/64

    WiFiNetwork         wifi      UP

NODES      Name    Interface    Type                                          IPs
   01ThreadNode        wpan0  thread   2001:0db8:0001:0002:3e36:13ff:fe33:732e/64

 02BorderRouter        wpan0  thread   2001:0db8:0001:0002:a651:3eff:fe92:6dbc/64

                       wlan0    wifi
     03WiFiNode        wlan0    wifi

W przypadku sieci Wi-Fi dodaj prefiksy IPv4 i IPv6:

$ happy-network-address WiFiNetwork 2001:db8:a:b::
$ happy-network-address WiFiNetwork 10.0.1.0

Sprawdź jeszcze raz stan Happy. Wszystkie interfejsy mają przypisane adresy IP, po dwa dla każdego interfejsu Wi-Fi:

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes
  ThreadNetwork       thread      UP                       2001:0db8:0001:0002/64

    WiFiNetwork         wifi      UP                       2001:0db8:000a:000b/64
                                                                        10.0.1/24


NODES      Name    Interface    Type                                          IPs
   01ThreadNode        wpan0  thread   2001:0db8:0001:0002:3e36:13ff:fe33:732e/64

 02BorderRouter        wpan0  thread   2001:0db8:0001:0002:a651:3eff:fe92:6dbc/64

                       wlan0    wifi                                  10.0.1.2/24
                                       2001:0db8:000a:000b:426c:38ff:fe90:01e6/64

     03WiFiNode        wlan0    wifi   2001:0db8:000a:000b:9aae:2bff:fe71:62fa/64
                                                                      10.0.1.3/24

Oto nasza zaktualizowana topologia:

84eecd23871618ca.png

Teraz, że nasza sieć jest szczęśliwy i działa, niech przetestować swoją łączność poprzez pingowanie inne węzły z 01ThreadNode :

$ happy-ping 01ThreadNode 02BorderRouter
[Ping] ping from 01ThreadNode to 02BorderRouter on address
    10.0.1.2 -> 100% packet loss
[Ping] ping from 01ThreadNode to 02BorderRouter on address
    2001:0db8:0001:0002:a651:3eff:fe92:6dbc -> 0% packet loss
[Ping] ping from 01ThreadNode to 02BorderRouter on address
    2001:0db8:000a:000b:426c:38ff:fe90:01e6 -> 100% packet loss

$ happy-ping 01ThreadNode 03WiFiNode
[Ping] ping from 01ThreadNode to 03WiFiNode on address
    2001:0db8:000a:000b:9aae:2bff:fe71:62fa -> 100% packet loss
[Ping] ping from 01ThreadNode to 03WiFiNode on address
    10.0.1.3 -> 100% packet loss

The happy-ping stara komenda ping każdy adres IP dla każdego interfejsu w węźle docelowym. Możemy zignorować adresy IPv4, ponieważ Thread używa tylko IPv6.

Należy pamiętać, że tylko jeden ping IPv6 był udany: jeden na 02BorderRouter „s wpan0 interfejs, który jest tylko adres 01ThreadNode mogą bezpośrednio dotrzeć:

5447bcbdf7d539df.png

Pozostałe adresy IPv6 nie powiodła się, ponieważ przekazywanie zostało włączone pomiędzy wpan0 i wlan0 na 02BorderRouter . Zatem 01ThreadNode ma pojęcia 03WiFiNode istnieje, albo jak go osiągnąć. Happy przedstawił symulowaną sieć, ale nie włączył całego routingu i przekazywania między węzłami.

Dodaj trasy

Aby skierować ruch IPv6 przez sieć HAN, dodaj odpowiednie trasy do każdego węzła w każdej sieci w obu kierunkach (aby ping wiedział, jak wrócić do węzła źródłowego).

Dla każdego węzła musisz wiedzieć:

  • najbliższa brama sieciowa, w tym przypadku, 02BorderRouter zarówno
  • sieć docelowa — dokąd iść za bramą

W przypadku naszej sieci z trzema węzłami daje nam to:

z sieci źródłowej

do sieci docelowej

przez bramkę

ThreadNetwork

WiFiNetwork

02BorderRouter wlan0 2001:db8:1:2::/64 prefix

WiFiNetwork

ThreadNetwork

02BorderRouter wpan0 2001:db8:a:b::/64 prefix

Można to zrobić indywidualnie dla każdego węzła z happy-node-route , ale łatwiej to zrobić dla wszystkich węzłów w każdej sieci z happy-network-route .

$ happy-network-route -a -i ThreadNetwork -t default -v 02BorderRouter -p 2001:db8:1:2::/64
$ happy-network-route -a -i WiFiNetwork -t default -v 02BorderRouter -p 2001:db8:a:b::/64

Dla wyjaśnienia flagi wiersza polecenia, należy użyć happy-network-route -h .

happy-network-route komenda powoduje również na przekazywanie IPv4 i IPv6 dla każdego węzła, w zależności od potrzeb. Pozwala to na kierowanie ruchu z jednego interfejsu do drugiego w węźle.

Teraz ponów próbę ping:

$ happy-ping 01ThreadNode 02BorderRouter
[Ping] ping from 01ThreadNode to 02BorderRouter on address
    10.0.1.2 -> 100% packet loss
[Ping] ping from 01ThreadNode to 02BorderRouter on address
    2001:0db8:0001:0002:a651:3eff:fe92:6dbc -> 0% packet loss
[Ping] ping from 01ThreadNode to 02BorderRouter on address
    2001:0db8:000a:000b:426c:38ff:fe90:01e6 -> 0% packet loss

Oba pingi IPv6 działają! Z przekazywania dalej, to wie, jak dotrzeć do wlan0 interfejs. Ping IPv4 nadal się nie udaje, ponieważ skonfigurowaliśmy tylko trasy i przekazywanie IPv6 (również dlatego, że Thread nie działa przez IPv4).

Ponieważ dodaliśmy trasy sieciowe po obu stronach, wykonajmy ping między sieciami:

$ happy-ping 01ThreadNode 03WiFiNode
[Ping] ping from 01ThreadNode to 03WiFiNode on address
    2001:0db8:000a:000b:9aae:2bff:fe71:62fa -> 0% packet loss
[Ping] ping from 01ThreadNode to 03WiFiNode on address
    10.0.1.3 -> 100% packet loss

Ping IPv6 działa zgodnie z oczekiwaniami. Masz teraz w pełni funkcjonalną, symulowaną sieć HAN IPv6.

5bb53be0280b3320.png

Aby umożliwić bezpieczniejszy i bardziej niezawodny sposób łączenia wszystkiego razem, dodajmy Weave do HAN.

Weave to warstwa aplikacji sieciowych, która zapewnia bezpieczny i niezawodny szkielet komunikacyjny dla produktów Nest. Możemy dodać funkcjonalność Weave z OpenWeave, wersją Weave o otwartym kodzie źródłowym.

Implementacja Weave nazywana jest „tkaniną”. Struktura Weave to sieć, która obejmuje wszystkie węzły HAN, usługę Nest i wszelkie urządzenia mobilne uczestniczące w sieci HAN. Znajduje się na szczycie sieci HAN i umożliwia łatwiejsze trasowanie w różnych podstawowych technologiach łączy sieciowych (na przykład wątku lub Wi-Fi).

Tworzenie splot tkaniny dla HAN, używając fab1 jako identyfikator Fabric, a następnie skonfigurować wszystkie węzły na Weave:

$ weave-fabric-add fab1
$ weave-node-configure

Teraz, gdy Weave jest skonfigurowany, sprawdź stan Happy:

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes
  ThreadNetwork       thread      UP                       2001:0db8:0001:0002/64

    WiFiNetwork         wifi      UP                       2001:0db8:000a:000b/64
                                                                        10.0.1/24


NODES      Name    Interface    Type                                          IPs
   01ThreadNode        wpan0  thread   2001:0db8:0001:0002:3e36:13ff:fe33:732e/64
                                       fd00:0000:fab1:0006:6bca:9502:eb69:11e7/64

 02BorderRouter        wpan0  thread   fd00:0000:fab1:0006:6a6a:f236:eb69:11e7/64
                                       2001:0db8:0001:0002:a651:3eff:fe92:6dbc/64

                       wlan0    wifi   fd00:0000:fab1:0001:6a6a:f236:eb69:11e7/64
                                                                      10.0.1.2/24
                                       2001:0db8:000a:000b:426c:38ff:fe90:01e6/64

     03WiFiNode        wlan0    wifi   2001:0db8:000a:000b:9aae:2bff:fe71:62fa/64
                                                                      10.0.1.3/24
                                       fd00:0000:fab1:0001:6b82:6e60:eb69:11e7/64

Każdy węzeł został dodany w splocie, każdy interfejs ma nowy adres IPv6 zaczynając fd00 . Aby uzyskać więcej informacji na temat splocie, użyj weave-state polecenie:

$ weave-state

State Name: weave

NODES           Name       Weave Node Id    Pairing Code
        01ThreadNode    69ca9502eb6911e7          8ZJB5Q
      02BorderRouter    686af236eb6911e7          B5YV3P
          03WiFiNode    69826e60eb6911e7          L3VT3A

FABRIC     Fabric Id           Global Prefix
                fab1     fd00:0000:fab1::/48

Oto nasza zaktualizowana topologia z wartościami Weave w kolorze niebieskim:

ce3fa9082408355b.png

Splot tkaniny

W stanach Weave i Happy pojawiło się wiele nowych informacji. Początek spójrzmy prawdzie z tkaniny od weave-state :

FABRIC     Fabric Id           Global Prefix
                fab1     fd00:0000:fab1::/48

Wyplata wykorzystuje prefiks IPv6 fd00::/48 dla każdego węzła. Adresy w tym bloku nazywane są unikalnymi adresami lokalnymi i są przeznaczone do użytku w sieciach prywatnych, takich jak HAN. Połączenie tego z identyfikatorem tkaniny generuje pokazany powyżej globalny prefiks Weave.

Węzły splotu

Każdemu węzłowi w strukturze Weave przypisywany jest unikalny identyfikator węzła wraz z kodem parowania:

NODES           Name       Weave Node Id    Pairing Code
        01ThreadNode    69ca9502eb6911e7          8ZJB5Q
      02BorderRouter    686af236eb6911e7          B5YV3P
          03WiFiNode    69826e60eb6911e7          L3VT3A

Identyfikator węzła globalnie identyfikuje węzeł w tkaninie Weave. Kod parowania jest używany jako „poświadczenie łączenia” podczas procesu parowania i zazwyczaj jest drukowany wraz z kodem QR produktu.

Na przykład, jeśli spojrzysz na kod QR na urządzeniu Nest Protect lub kamerze Nest Cam, zauważysz ciąg składający się z sześciu znaków, często nazywany kluczem wejścia. To jest kod parowania Weave.

e7c6fa3e24d61d1b.png

Weave używa kombinacji globalnego prefiksu, identyfikatora sieci szkieletowej i identyfikatora węzła, aby utworzyć adresy IPv6 specyficzne dla Weave dla każdego węzła i interfejsu w strukturze.

Splot adresy

Należy pamiętać, że istnieją cztery nowe adresy IPv6 w szczęśliwym topologii, wszystko zaczynając od naszej Weave globalnego prefiksu fd00:0000:fab1::/48 .

NODES      Name    Interface    Type                                          IPs
   01ThreadNode        wpan0  thread   2001:0db8:0001:0002:3e36:13ff:fe33:732e/64
                                       fd00:0000:fab1:0006:6bca:9502:eb69:11e7/64

 02BorderRouter        wpan0  thread   fd00:0000:fab1:0006:6a6a:f236:eb69:11e7/64
                                       2001:0db8:0001:0002:a651:3eff:fe92:6dbc/64

                       wlan0    wifi   fd00:0000:fab1:0001:6a6a:f236:eb69:11e7/64
                                                                      10.0.1.2/24
                                       2001:0db8:000a:000b:426c:38ff:fe90:01e6/64

     03WiFiNode        wlan0    wifi   2001:0db8:000a:000b:9aae:2bff:fe71:62fa/64
                                                                      10.0.1.3/24
                                       fd00:0000:fab1:0001:6b82:6e60:eb69:11e7/64

Protokoły Weave używają tych adresów do komunikacji w strukturze Weave, a nie standardowych adresów IPv6 przypisanych do każdego węzła.

Weave brama sieciowa

Węzły Weave w sieci Thread muszą wiedzieć, gdzie wyjść z tej sieci. Brama sieciowa Weave — zwykle na routerze Thread Border Router — zapewnia tę funkcję.

W naszej przykładowej topologii wyznaczmy węzeł BorderRouter jako bramę sieci Weave:

$ weave-network-gateway ThreadNetwork 02BorderRouter

To polecenie dodaje trasy ze wszystkich węzłów wątek splot podsieci tkaniny ( fd:0:fab1::/48 ) za pośrednictwem BorderRouter węzła interfejsu wątek ( wpan0 ), która umożliwia każdy węzeł wątku dotrzeć do każdego Weave węzeł poza siecią wątku. Jest to analogiczne do happy-network-route polecenia używaliśmy wcześniej, ale specyficzny splot dróg tkaniny.

To, co sprawia, że ​​Happy jest tak potężny, to łatwość zarządzania konfiguracją i niszczeniem symulowanej topologii.

Zapisz swoją topologię Happy do późniejszego wykorzystania:

$ happy-state -s codelab.json

Stawia to plik JSON z pełną topologią w swoim głównym ~/ folderu. Plik JSON jest kopią aktualnego szczęśliwego stanu, który znajduje się w ~/.happy_state.json .

Po zapisaniu usuń bieżącą topologię:

$ happy-state-delete

Spowoduje to usunięcie wszystkich nazw sieciowych i związanych z nimi konfiguracje znajdujące się w ~/.happy-state.json pliku. Sprawdzić happy-state i weave-state , aby potwierdzić pustą konfigurację:

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes

NODES      Name    Interface    Type                                          IPs


$ weave-state

State Name: weave

NODES           Name       Weave Node Id    Pairing Code

FABRIC     Fabric Id           Global Prefix

Aby ponownie wczytać zapisaną konfigurację, użyj jednego z dwóch poleceń:

  • happy-state-load - nie obsługuje wtyczki Weave
  • weave-state-load - Obsługa wtyczek Weave

Więc jeśli topologia zawiera splot, zawsze używać weave-state-load polecenia tak, że jest zastosowany splot tkaniny i Associated konfiguracja.

Wczytaj ponownie zapisaną topologię Happy:

$ weave-state-load codelab.json

Sprawdź wszystkie stany, aby potwierdzić pomyślne wczytanie:

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes
  ThreadNetwork       thread      UP                       2001:0db8:0001:0002/64

    WiFiNetwork         wifi      UP                       2001:0db8:000a:000b/64
                                                                        10.0.1/24


NODES      Name    Interface    Type                                          IPs
   01ThreadNode        wpan0  thread   2001:0db8:0001:0002:eef6:a0ff:feca:6697/64
                                       fd00:0000:fab1:0006:6bca:9502:eb69:11e7/64

 02BorderRouter        wpan0  thread   fd00:0000:fab1:0006:6a6a:f236:eb69:11e7/64
                                       2001:0db8:0001:0002:5e53:bbff:fe05:484b/64

                       wlan0    wifi   2001:0db8:000a:000b:2e61:fdff:fed9:4fbc/64
                                       fd00:0000:fab1:0001:6a6a:f236:eb69:11e7/64
                                                                      10.0.1.2/24

     03WiFiNode        wlan0    wifi   fd00:0000:fab1:0001:6b82:6e60:eb69:11e7/64
                                                                      10.0.1.3/24
                                       2001:0db8:000a:000b:5e8e:c9ff:fed2:bdd1/64


$ weave-state

State Name: weave

NODES           Name       Weave Node Id    Pairing Code
        01ThreadNode    69ca9502eb6911e7          8ZJB5Q
      02BorderRouter    686af236eb6911e7          B5YV3P
          03WiFiNode    69826e60eb6911e7          L3VT3A

FABRIC     Fabric Id           Global Prefix
                fab1     fd00:0000:fab1::/48

W repozytorium Happy udostępniono szereg predefiniowanych topologii, zarówno w formacie skryptu powłoki, jak i JSON. Znaleźć je w ~/happy/topologies .

OpenWeave zawiera również wybrane predefiniowane topologie Happy do celów testowych. Znaleźć je w ~/openweave-core/src/test-apps/happy/topologies/standalone .

Happy używa przestrzeni nazw sieciowych Linuksa do symulacji złożonych topologii. Zazwyczaj konfiguracja sieci dotyczy całego systemu operacyjnego Linux. Sieciowe przestrzenie nazw umożliwiają partycjonowanie konfiguracji sieciowych tak, aby każda przestrzeń nazw miała swój własny zestaw interfejsów i tabel routingu.

Każdy węzeł i sieć w Happy to przestrzeń nazw sieci, a łącza między nimi to interfejsy sieciowe.

Na przykład, korzystając z naszej topologii:

7d6654c2e4907f2a.png

Zobaczmy, jakie przestrzenie nazw stworzył w tym celu Happy:

$ ip netns list
happy004
happy003
happy002
happy001
happy000

Jeśli zaznaczysz netns odcinek Happy państwowej pliku JSON, można zobaczyć, co węzłów i sieci każdy odpowiada przestrzeni nazw do:

$ happy-state -j | grep "netns" -A 5
"netns": {
    "01ThreadNode": "000",
    "02BorderRouter": "001",
    "03WiFiNode": "002",
    "ThreadNetwork": "003",
    "WiFiNetwork": "004",

49cfdce6ff9dd745.png

Dzienniki czasu wykonywania

Polecenia wydawane węzłom to podstawowe polecenia terminala wykonywane z przestrzeni nazw każdego węzła. Prostym sposobem na sprawdzenie tego jest włączenie dzienników Happy run-time.

Otwórz drugie okno terminala i włącz logi, będą one działały nieprzerwanie w tym oknie:

$ happy-state -l

Wróć do pierwszego okna i uruchom Happy ping:

$ happy-ping 01ThreadNode 02BorderRouter

Sprawdź najnowsze wpisy dziennika w drugim oknie terminala. Powinieneś zobaczyć taką linię w logach:

DEBUG [Driver:CallCmd():416] Happy [happy]: > sudo ip netns exec happy000 ping6 -c 1 2001:0db8:0001:0002:5e53:bbff:fe05:484b

happy-ping komenda nie jest niczym więcej niż szczęśliwy, uruchamiając ping6 polecenie w happy000 nazw ( 01ThreadNode ).

Wpisz węzeł

Użyj happy-shell uruchomić non-happy polecenia jakby zalogowany do jednego z węzłów (Sieciowe przestrzenie nazw):

$ happy-shell 01ThreadNode
root@01ThreadNode:#

Symulowane urządzenia są uruchamiane w każdej przestrzeni nazw i mają dostęp tylko do konfiguracji sieci określonej przez Happy.

Sprawdź konfigurację interfejsu dla węzła. Będzie się to różnić od konfiguracji całego systemu operacyjnego i powinno odzwierciedlać to, co jest wymienione w stanie Szczęśliwego:

root@01ThreadNode:# ifconfig
lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:1 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1
          RX bytes:152 (152.0 B)  TX bytes:152 (152.0 B)

wpan0     Link encap:Ethernet  HWaddr ec:f6:a0:ca:66:97
          inet6 addr: fd00:0:fab1:6:6bca:9502:eb69:11e7/64 Scope:Global
          inet6 addr: 2001:db8:1:2:eef6:a0ff:feca:6697/64 Scope:Global
          inet6 addr: fe80::eef6:a0ff:feca:6697/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:32 errors:0 dropped:0 overruns:0 frame:0
          TX packets:26 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:2832 (2.8 KB)  TX bytes:2348 (2.3 KB)

Użyj exit do opuszczenia przestrzeni nazw w węźle:

root@01ThreadNode:# exit

Rozumiejąc, w jaki sposób Happy używa przestrzeni nazw sieci Linux, możesz teraz zdać sobie sprawę, że możliwe jest podłączenie symulowanej sieci Happy do Internetu i uzyskanie dostępu do publicznych adresów z symulowanych węzłów. Jest to przydatne do łączenia symulowanych urządzeń z prawdziwą usługą (np. Nest Service over Weave).

Usługa w Weave to infrastruktura oparta na chmurze, która łączy węzły HAN w model danych, zapewnia zdalny dostęp i wdraża inteligentne kontrolery w celu stworzenia kompleksowego ekosystemu.

Usługa może być reprezentowana w Happy na dwa podstawowe sposoby:

  • Jako symulowana usługa we własnej sieciowej przestrzeni nazw (Happy node)
  • Jako prawdziwa usługa w chmurze w Internecie

Zaprogramowane topologie zostały dostarczone w ~/happy/topologies jako przykład każdego scenariusza serwisowego.

Symulowana usługa na węźle Happy

Usuń wszystkie istniejące topologie Happy:

$ happy-state-delete

Potwierdź pusty członkowskiego z happy-state i weave-state komend.

Załaduj wstępnie zdefiniowaną topologię z punktem dostępowym (AP) i węzłami usługowymi:

$ weave-state-load ~/happy/topologies/thread_wifi_ap_service.json

6d04cbfcc84038e2.png

Sprawdź stany Happy i Weave, aby potwierdzić topologię. W tej topologii, onhub jest AP, podczas gdy cloud jest symulowane serwis. Uwaga oba są podłączone do Internet sieci typu wan :

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes
     HomeThread       thread      UP                       2001:0db8:0111:0001/64

       HomeWiFi         wifi      UP                       2001:0db8:0222:0002/64
                                                                        10.0.1/24

       Internet          wan      UP                               192.168.100/24


NODES      Name    Interface    Type                                          IPs
   BorderRouter        wpan0  thread   2001:0db8:0111:0001:f624:13ff:fe4a:6def/64
                                       fd00:0000:fab1:0006:1ab4:3000:0000:0005/64

                       wlan0    wifi                                  10.0.1.2/24
                                       fd00:0000:fab1:0001:1ab4:3000:0000:0005/64
                                       2001:0db8:0222:0002:9e31:97ff:fe73:29f0/64

     ThreadNode        wpan0  thread   2001:0db8:0111:0001:c237:fbff:fecc:b082/64
                                       fd00:0000:fab1:0006:1ab4:3000:0000:0009/64

          cloud         eth0     wan                             192.168.100.3/24

          onhub        wlan0    wifi                                  10.0.1.3/24
                                       2001:0db8:0222:0002:3266:20ff:fe98:6ee2/64

                        eth0     wan                             192.168.100.2/24


$ weave-state

State Name: weave

NODES           Name       Weave Node Id    Pairing Code
        BorderRouter    18B4300000000005          AAA123
          ThreadNode    18B4300000000009          AAA123

FABRIC     Fabric Id           Global Prefix
                fab1     fd00:0000:fab1::/48

Splot tunelu

Tunel Weave łączy tkaninę Weave z usługą. Jest to bezpieczna trasa, która przesyła komunikaty IPv6 UDP między siecią HAN a usługą. W tej topologii The BorderRouter węzeł jest splot interfejs sieciowy, który funkcjonuje jako punkt końcowy tunelu na HAN.

Utwórz tunel Splotu:

$ weave-tunnel-start BorderRouter cloud

Sprawdź ponownie stan Happy. Powinieneś zobaczyć nowy interfejs tunelu z adresem IPv6 Weave na cloud węźle:

NODES      Name    Interface    Type                                          IPs

          cloud service-tun0     tun   fd00:0000:fab1:0005:1ab4:3002:0000:0011/64

                        eth0     wan                             192.168.100.3/24

c5ffca09d7cd3208.png

Teraz możesz pomyślnie pingować między węzłami w strukturze Weave i globalnym prefiksem Weave usługi:

$ happy-ping ThreadNode cloud
[Ping] ping from ThreadNode to cloud on address
    fd00:0000:fab1:0005:1ab4:3002:0000:0011 -> 0% packet loss

Prawdziwa usługa w chmurze w Internecie

Usuń wszystkie istniejące topologie Happy:

$ happy-state-delete

Potwierdź pusty członkowskiego z happy-state i weave-state komend.

Załaduj wstępnie zdefiniowaną topologię z węzłem punktu dostępowego (AP):

$ weave-state-load ~/happy/topologies/thread_wifi_ap_internet.json

c75127417ef3833a.png

W tej topologii, onhub jest AP. Sprawdź stan Happy. Jest podobny do poprzedniego topologii bez Internet sieci i cloud węźle:

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes
     HomeThread       thread      UP                       2001:0db8:0111:0001/64

       HomeWiFi         wifi      UP                       2001:0db8:0222:0002/64
                                                                        10.0.1/24


NODES      Name    Interface    Type                                          IPs
   BorderRouter        wpan0  thread   2001:0db8:0111:0001:ca3f:71ff:fe53:1559/64
                                       fd00:0000:fab1:0006:1ab4:3000:0000:0006/64

                       wlan0    wifi   2001:0db8:0222:0002:32e7:dfff:fee2:107a/64
                                       fd00:0000:fab1:0001:1ab4:3000:0000:0006/64
                                                                      10.0.1.2/24

     ThreadNode        wpan0  thread   2001:0db8:0111:0001:c2fb:97ff:fe04:64bd/64
                                       fd00:0000:fab1:0006:1ab4:3000:0000:000a/64

          onhub        wlan0    wifi                                  10.0.1.3/24
                                       2001:0db8:0222:0002:3a3c:8dff:fe38:999b/64


$ weave-state

State Name: weave

NODES           Name       Weave Node Id    Pairing Code
        BorderRouter    18B4300000000006          AAA123
          ThreadNode    18B430000000000A          AAA123

FABRIC     Fabric Id           Global Prefix
                fab1     fd00:0000:fab1::/48

Ponieważ każdy węzeł Happy jest przestrzenią nazw sieci, są one domyślnie oddzielone od publicznego Internetu. Przetestuj to, wprowadzając węzeł Happy i pingując publiczny adres internetowy. Użyjemy 8.8.8.8 , jeden z google.com na adresy IPv4.

$ happy-shell onhub
root@onhub:# ping -c2 8.8.8.8
connect: Network is unreachable

Aby połączyć onhub węzeł do internetu, musi być zmostkowane do tego interfejsu na poziomie konfiguracji OS Linux.

Wyjdź z węzła:

root@onhub:# exit

Ustal interfejs dla połączenia internetowego z route poleceniem:

$ route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         192.168.1.0     0.0.0.0         UG    0      0        0 em1

Znajdź default trasę. To jest połączenie internetowe dla twojego komputera z systemem Linux. Iface kolumna zawiera interfejs, który jest używany dla tego połączenia. W powyższym przykładzie, to em1 .

Użyj happy-internet skonfigurować most, przy użyciu interfejsu dla swojej trasy domyślnej. Dla --isp flag, używać nazwy interfejsu bez spływu liczb. W tym przykładzie jest to em . Jeśli domyślny interfejs eth1 The --isp flaga byłaby eth .

$ happy-internet --node onhub --interface em1 --isp em --seed 249

Nie będzie widoczna zmiana w happy-state wyjścia, ale onhub węzeł powinien mieć połączenie z Internetem. Wróćmy do węzła i sprawdźmy:

$ happy-shell onhub
root@onhub:# ping -c2 8.8.8.8
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=56 time=1.81 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=56 time=1.81 ms

--- 8.8.8.8 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 1.814/1.816/1.819/0.042 ms

Sukces!

c4d411ab1734131.png

DNS

Szczęśliwe węzły nie mają wbudowanych funkcji DNS. Jeśli spróbujesz pingować google.com, nie powiedzie się:

root@onhub:# ping -c2 google.com
ping: unknown host google.com

Na szczęście Happy zapewnia wsparcie dla DNS. Wyjdź z węzła i znajdź serwery DNS dla swojego komputera z systemem Linux. Upewnij się, że używasz odpowiedniego domyślnego interfejsu:

root@onhub:# exit
$ nmcli dev list iface em1 | grep domain_name_servers
DHCP4.OPTION[13]:                       domain_name_servers = 172.16.255.1 172.16.255.153 172.16.255.53

Użyj tych adresów DNS z happy-dns :

$ happy-dns 172.16.255.1 172.16.255.153 172.16.255.53

Teraz pingnij google.com od wewnątrz onhub węźle:

$ happy-shell onhub
root@onhub:# ping -c2 google.com
PING google.com (64.233.191.113) 56(84) bytes of data.
64 bytes from ja-in-f113.1e100.net (64.233.191.113): icmp_seq=1 ttl=46 time=36.9 ms
64 bytes from ja-in-f113.1e100.net (64.233.191.113): icmp_seq=2 ttl=46 time=37.0 ms

--- google.com ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 36.978/36.995/37.013/0.193 ms

Wyjdź z onhub węzeł kiedy skończysz:

root@onhub:# exit

Splot tunelu

Podobnie jak symulowana usługa, tunel Weave musi być ustawiony między symulowaną siecią HAN w Happy a usługą. W przypadku prawdziwej usługi w chmurze użyj adresu IP lub adresu URL usługi w konfiguracji tunelu. Na przykład:

$ weave-tunnel-start BorderRouter mycloud.service.com

3ed2c3c0df67f4d2.png

Ważne jest, aby zawsze czyścić topologie Happy, gdy już z nimi skończysz, aby uniknąć problemów z konfiguracją sieci w Linuksie.

Jeśli włączono obsługę DNS w topologii, należy go usunąć przez ponowne uruchomienie tego polecenia z -d pierwsza flaga (Usuń). Należy to uruchomić przed usunięciem wszystkich węzłów Happy, aby upewnić się, że konfiguracja sieci jest prawidłowo aktualizowana.

$ happy-dns -d 172.16.255.1 172.16.255.153 172.16.255.53

Następnie usuń stan Szczęśliwy:

$ happy-state-delete

Czasami niektóre pliki stanu mogą pozostać po usunięciu stanu. Jeśli napotkasz problemy i szczęśliwy nie działa zgodnie z oczekiwaniami, należy usunąć stan z happy-state-delete , a następnie wykonaj następujące polecenia, aby zmusić resztki posprzątać:

$ ip netns | xargs -I {} sudo ip netns delete {}
$ rm -rf ~/.*state.json
$ rm -rf ~/.*state.json.lock

Twój komputer powinien wrócić do normalnej konfiguracji sieciowej.

Teraz wiesz:

  • Jak używać Happy do symulacji własnych sieci domowych IoT?
  • Jak podłączyć topologie Happy do Internetu?
  • Podstawy Weave za pośrednictwem OpenWeave, otwartej wersji Weave firmy Nest

Następne kroki

Opierając się na tym ćwiczeniu z programowania, wypróbuj następujące ćwiczenia:

  • Utwórz większą topologię z wieloma węzłami w każdym wątku i sieci Wi-Fi oraz nawiąż łączność między wszystkimi węzłami
  • Utwórz skrypt bash, aby załadować topologię przez happy-state-load lub weave-state-load
  • Przeglądaj inne Szczęśliwi poleceń, takich jak happy-traceroute i happy-process-*

Dalsza lektura

Sprawdzić openweave.io dla różnych referencji, w tym:

f6996428fb06dede.png