Wersja 6

Wersja 6.0 ElasticSearch jest dla mnie szczególna - twórcy wprowadzają zmiany ułatwiające zarządzanie, ale też rezygnują z dawnych błędów, które krytykowałem na łamach tego bloga.

Każdemu polecam migrację do wersji 6.x. Służę pomocą w migracji z wersji 2.x oraz 5.x.

Aktualizacje ElasticSearch - jak wykonać?

Nie można zaprzeczyć, że ElasticSearch jest rozwijany dynamicznie. Tak szybki rozwój produktu nie zawsze jest oczekiwany, bo albo wdrożenie zostaje (z przyczyn obiektywnych) oparte o zamrożoną (i nie wspieraną) wersję, albo konieczne staje się przeprowadzanie migracji do nowszych wersji. Takie operacje trzeba zaplanować, zabudżetować, a na dodatek nie obejdzie się bez downtime i sukcesem jest, gdy przerwa techniczna jest relatywnie krótka.

Przypomnę w tym miejscu daty końca wsparcia poszczególnych wersji ElasticSearch:

Przygotowując się do jakichkolwiek operacji powinno się opracować procedurę, z którą należy zapoznać wszystkich zainteresowanych, opracować procedurę odwrotną, tj. wycofującą zmiany w razie nieprzewidzianych problemów, albo oznaczyć jasno punkty po realizacji których nie ma już odwrotu.

W przypadku ElasticSearch procedura jest o tyle bezpieczna, że ryzyko utraty danych jest stosunkowo niewielkie i ogranicza się do przypadku utraty danych z kartoteki wtórnej (zazwyczaj bazy danych RDBMS systemu OLTP), co ma miejsce niezwykle rzadko ale jest możliwe (a jak coś jest możliwe, to zazwyczaj dzieje się w najgorszym momencie).

Czy można śmiało aktualizować ElasticSearch? Tak, ale pod warunkiem, że został zapewniony backup danych lub środowiska. Największym problemem jest downtime, czyli czas braku usługi, który będzie skutkował wyłączeniem bądź dysfunkcją aplikacji web.

A czy warto aktualizować? Tak!

Aktualizacja od 5.x

Producent zapewnia, że aktualizacja od wersji 5.6.3 nie wymaga downtime. Zachowanie kompatybilności wstecznej na poziomie fizycznym jest ogromnym plusem tego wydania.

Wyjątkiem jest użycie X-Pack Security bez SSL/TLS, co wymaga przekonfigurowania węzłów (włączenia SSL/TLS) i restartu całego klastra. Pomijam przypadki, gdzie w stacku używana jest np. Kibana i najlepiej użyć jest asystenta migracji.

Etapy migracji warto zatem podzielić na: - migrację 2.x do 5 - migrację 5.x do 5.6.3 - migrację 5.6.3 do 6.x

Koniec z mappingami

Nie mogę powiedzieć, że to mój osobisty sukces, ale wersja 6.0 wycofuje tzw. mappingi, czyli grupowanie atrybutów w bliżej nieokreślonym celu. O bezsensie mappingów pisałem szerzej we wpisie z 2016 roku.

Dzięki temu posunięciu indeksy są w końcu takie, jakie powinny być. Tworzenie bibliotek klienckich też staje się o prostsze (dokładnie o jedną warstwę), gdyż struktura indeksu nie musi być opisywana wieloma mappingami. Wydajność takich indeksów staje się lepsza, a zarządzanie nimi - prostsze.

ElasticSearch 6.x zachowuje kompatybilność pozostawiając obsługę mappingów w starych indeksach, sam ogranicza tworzenie dokładnie jednego mappingu do indeksu, aż w wersji 7.0 mappingi zostaną kompletnie usunięte (z wyjątkami w 9.0).

Twórcy ElasticSearch argumentują zmiany takimi słowami:

In the early days of Elasticsearch, we spoke about an “index” being similar to a “database” in an SQL database, and a “type” being equivalent to a “table”. This was a bad analogy that led to incorrect assumptions. In an SQL database, tables are independent of each other. The columns in one table have no bearing on columns with the same name in another table. This is not the case for fields in a mapping type.

Tak. Ta analogia była po prostu głupia.

In an Elasticsearch index, fields that have the same name in different mapping types are backed by the same Lucene field internally. In other words, using the example above, the user_name field in the user type is stored in exactly the same field as the user_name field in the tweet type, and both user_name fields must have the same mapping (definition) in both types.

I dokładnie to krytykowałem w moim poprzednim wpisie.

Cieszę się, że twórcy ElasticSearch w końcu to dostrzegli. Czekam, aż przyjmą do wiadomości, że ich API HTTP/JSON nie jest RESTful :)

Co nowego w ElasticSearch 6.0?

Wersja 6.0, oprócz pierwszych kroków do usunięcia naprawdę głupich mappingów, poprawia wydajność wyszukiwania, szczególnie skracając czasy wyszukiwania posortowanych zbiorów, ale też usprawnia w wyszukiwanie rozproszone oraz bezpieczeństwo.

To pierwsza wersja ElasticSearch, do której gorąco namawiam obecnych i potencjalnych klientów. Zainteresowanych proszę o kontakt przez stronę firmową lub telefonicznie +48326100016.

Prawa Murphy'ego znane sią chyba każdemu, także osobom nietechnicznym, od dobrych dwóch dekad. W tym krótkim wpisie przytoczę kilka "praw", które zazwyczaj traktowane z przymrużeniem oka, są podstawą rzemiosła profesjonalisty, a szczególnie administratora lub wdrożeniowca.

Stosując metodykę DevOps, a nawet ograniczając się tylko do samego continuous delivery lub continuous deployment, istotnym czynnikiem jest zapewnienie jakości. Przeprowadzając wszelakie operacje w środowiskach produkcyjnych istnieją dwie naczelne zasady: możliwie najkrótszy downtime (lub zero downtime) oraz niedopuszczanie do wprowadzania wadliwych wersji.

Mówiąc ogólnie - naczelną zasadą jest nie szkodzić użytkownikowi eksploatowanego systemu. A jak powszechnie wiadomo człowiek jest z zasady istotą omylną, najsłabszym ogniwem każdego łańcucha, dlatego do zapewnienia jakości każdemu profesjonaliście potrzebne są odpowiednie procedury postępowania.

Ciekawą pomocą w ich opracowywaniu, prawdopodobnie stosowaną powszechnie nieświadomie, są moim zdaniem Prawa Murphy'ego. Każdy odpowiedzialny profesjonalista powinien być w jakiejś części sceptykiem i pesymistą, choć niekoniecznie musi to okazywać ;)

Jeżeli coś może się nie udać, to się nie uda.
Jeśli coś może pójść źle, to pójdzie.

Powinny być podstawowymi zasadami każdego inżyniera operującego w środowiskach produkcyjnych. Błąd operatora jest jedną z najczęstszych przyczyn awarii. Przykłady można mnożyć - od przypadkowych usunięć danych, długich dysfunkcji usług sieciowych (co jest krytyczne w modelu SaaS), aż po spektakularne wycieki danych (spowodowane np. pozostawieniem "otwartego na świat" narzędzia). Nie, chmury nie rozwiązują "magicznie" takich problemów ;)

Opracowując procedury postępowania, czy to tworząc playbooki Ansible lub innego narzędzia orkiestracji, czy też wykonując operacje typowo manualne, powinno się mieć na uwadze że każdy krok może się nie powieść. Powinno się też przewidzieć w jakim stanie będzie system i jaki będzie sposób przywrócenia do stanu pierwotnego.

Jeśli wiesz, że coś może pójść źle i podejmiesz stosowne środki zapobiegawcze, to źle pójdzie coś innego

Zawsze trzeba mieć plan "B". Nawet zwykły backup. Często robiąc wdrożenia mocno modyfikujące dane, skracam RPO do absolutnego minimum tworząc kopie danych tuż po przejściu w tryb przerwy technicznej (aby wyeliminować napływ nowych danych). Czasem robię hotcopy zakładając, że częściowe odzyskanie danych będzie możliwe i nie będzie wiązać się z nadpisaniem nowszych informacji. Ostatecznie zawsze pod ręką powinien być backup całej maszyny lub okresowe dumpy danych.

Moje plany "B" zazwyczaj są wielowarstwowe, przez co na wiele niespodziewanych przypadków jestem odporny z zachowaniem RPO (Recovery Point Objective) oraz RTO (Recovery Time Objective) wynikającego z przyjętej polityki bezpieczeństwa.

Powinieneś być przerażony, gdy dziecko jest zbyt ciche.

Ta "prawda życiowa" ma swoją analogię w świecie IT. System wykazujący zbyt niskie obciążenie w stosunku do typowego dla danego dnia i pory dnia, powinien być poddany natychmiastowej inspekcji. Oznacza to, że konieczne są narzędzia monitorujące pracę systemu, ale nie tylko on-line ale również gromadzące dane historyczne. Nie ma lepszego sposobu jak ogląd krytycznych parametrów systemu w formie wykresów.

Tu warto zauważyć, że skuteczny monitoring wymaga personelu, który w niego patrzy i reaguje na jego zgłoszenia. Bez tego każdy system monitorowania jest niestety niemym głosem tonącego.

Nigdy nie mów „ups”, gdy pacjent jest przytomny

Profesjonalista nigdy nie poddaje się, gdy obsługuje awarię. Nie można wycofać się nawet wtedy, gdy za awarię w 100% odpowiedzialny jest ktoś inny. W opanowaniu sytuacji pomogą ci procedury i twoje plany "B".

Z tego wynika jeszcze coś, co nie jest oczywiste. Musi istnieć dokumentacja techniczna systemu, z której pomocą inżynier będzie mógł podejmować odpowiednie działania. Alternatywą jest posiadanie pełnej wiedzy o funkcjonowaniu całego systemu i sposobie jego obsługi, ale to podejście ma istotne wady, gdyż...

Wiedza i doświadczenie przychodzą z wiekiem. Najczęściej jest to wieko od trumny.

... każdy jest śmiertelny. Jeśli z nim zniknie wiedza, to biznes będzie miał niemały kłopot. Tworzenie dokumentacji technicznych oraz instrukcji obsługi systemu/podsystemów jest częścią pracy profesjonalisty. Zawsze trzeba na to mieć czas.

Ten, który się waha, ma prawdopodobnie rację

Trzeba być wyczulonym na takie sygnały. Wynikają one zazwyczaj z umiejętności przewidywania oraz z doświadczenia. Znowu zabezpieczeniem są procedury, plany "B".

Zawodowcy są przewidywalni – strzeż się amatorów

To się samo komentuje.

Drodzy webdeveloperzy!

Proszę, przestańcie tworzyć oprogramowanie webowe w TypeScript!

Natywnym językiem programowania dla webdevelopmentu jest implementacja EcmaScriptu w postaci Javascriptu. Kod generowany przez kompilator TypeScriptu jest zły, nieoptymalny, przypomina sieczkę generowaną przez GWT (tam: Java->JavaScript). Sam proces kompilacji jest czymś zupełnie zbędnym (TS -> kompilacja -> JS -> interpretacja -> wykonanie). To generuje koszt, jest bezzasadnym utrudnieniem. Źródła są niemodyfikowalne bez znajomości TypeScriptu, który jest zbędny przy tworzeniu bibliotek i produktów javascriptowych o przeznaczeniu webowym.

Używajcie TypeScript tam, gdzie jest on zasadny - we własnych projektach, w swoim Visual Studio, w rozszerzeniach do swoich projektów lub ogólnie projektów "niewebowych". Tam, gdzie efekt prac jest kodem wykonywanym przez przeglądarki webowe, stosujcie JavaScript.

Programując rozwiązania webowe w TypeScript popełniacie ogromny błąd.

Tym razem przedstawię rozwiązanie odwrotne do poprzedniego - zastosuję walidację schematem Colandera w formularzu Django.

Budując web API bardzo często istnieje potrzeba zwalidowania i odczytania nieco bardziej skomplikowanej struktury. W przypadku gdy po stronie serwera modelem jest obiekt klasy django.db.Model, to zapewne stosowany jest formularz klasy django.forms.ModelForm. To częsta i dosyć wygodna praktyka. Jednak jeśli wejście jest bardziej złożone, a dzieje się tak często podczas enkapsulacji interfejsu za pomocą RESTful API, to istnieje tendencja do tworzenia wielu formularzy, adapterów typu complex/composite forms, albo do zmiany modelu w celu odzwierciedlenia go w interfejsie 1:1.

Żadne z tych rozwiązań nie jest wystarczająco dobre, ponieważ wiele formularzy to bardziej złożona logika walidacji i brak spójności tejże (także w kontekście komunikatów o błędach), composite/complex forms narzucają tworzenie zlepek z wielu modeli (co też nie zawsze jest konieczne), a zmiany modelu mogą być zbędne i kosztowne.

Przypuśćmy, że bardziej złożona struktura to dodatkowy poziom zagnieżdżenia danych wejściowych. Naturalnym krokiem, szczególnie przy budowaniu JSON API, jest dodanie pola typu JSONField, ktore zdeserializuje część JSON-a do słownika. Byłoby to rozwiązanie dobre gdyby nie fakt, że walidacji podlega tylko syntaktyka przekazanej wartości. Nazwy kluczy, czyli ich prawidłowość oraz ich typy i wartości, pozostają nieweryfikowalne. I nie jest to winą JSON-a, tylko jego użycia (może wynikać wprost z zastosowania prostego pola typu JSONField).

Problem można rozwiązać używając pakietu Colander, za pomocą którego definiuje się dowolne schematy. Schematy Colander mogą być komponowane w złożone struktury, ale mogą być też używane pojedynczo. Colander nie narzuca tutaj żadnej konkretnej struktury oraz nie wprowadza zbędnych zależności, zatem użycie go jest bardzo wygodne.

Rozważmy bardzo prosty schemat opisujący współrzędne geograficzne:

class LocationSchema(colander.MappingSchema):
    lat = colander.SchemaNode(colander.Float())
    lng = colander.SchemaNode(colander.Float())

Powyższy schemat przyjmie słownik z kluczami lat oraz lng, których wartości muszą być liczbami zmiennoprzecinkowymi. Krótko mówiąc przyjmie on dane postaci: {"lat": 50.0, "lng": 50.0}.

Taki schemat można podpiąć bezpośrednio pod formularz Django, tak jak każde inne pole:

class LocationForm(forms.ModelForm):
    destination = ColanderSchemaField(LocationSchema, required=True)

Oczywiście potrzebny jest adapter - dedykowane pole dla formularzy Django, za pomocą którego proces walidacji zainstancjonuje schemat LocationSchema, zweryfikuje oraz oczyści dane wejściowe.

Ciało tego adaptera jest bardzo proste:

class ColanderSchemaField(forms.Field):
    def __init__(self, schema_factory, *args, **kwargs):
        self.schema_factory = schema_factory
        super(ColanderSchemaField, self).__init__(*args, **kwargs)

    def clean(self, value):
        if value is None:
            return

        schema = self.schema_factory()
        try:
            return schema.deserialize(value)
        except colander.Invalid as ex:
            raise forms.ValidationError(ex)

Od tej chwili formularz będzie oczekiwał klucza destination o strukturze określonej klasą LocationSchema.

Jednak zapis tej informacji oczywiście nie nastąpi, ponieważ ColanderSchemaField nie jest częścią modelu. Zapis trzeba przeprowadzić jawnie:

class LocationForm(forms.ModelForm):
    # ...

    def save(self, commit=True):
        instance = super(LocationForm, self).save(commit=False)
        destination = self.cleaned_data['destination']

        instance.destination_lat = destination['lat']
        instance.destination_lng = destination['lng']

        if commit:
            instance.save()
        return instance

Jeśli model miałby zdefiniowane pole destination klasy django.contrib.postgres.fields.JSONField lub analogicznej, to aktualizacja za pomocą ColanderSchemaField powinna przebiec automatycznie bez konieczności nadpisywania metody save(). Niestety jeszcze nie testowałem tego wariantu, do czego gorąco zachęcam.

Budując REST API mogą przydać się walidatory danych wejściowych bardziej elastyczne niż formularze Django. Do realizacji tego celu polecam i używam Colander.

Colander jest świetnym pakietem do (de)serializacji danych. Jest to odpowiednik formularzy Django dla Pyramida, lecz zdecydowanie bardziej elastyczny oraz bez związku HTML. Formularze Django są źle zaprojektowane - zbyt ściśle związane z HTML (widgety), których przecież nie używamy budując REST API, oraz są ograniczone do płaskich struktur. Jedynie jest są dyspozycji formsety, co pozwala zwalidować i zdeserializować listę obiektów jednego typu.

Colander wolny jest od tych wad, a ponieważ nie ma zależności od Pyramid (jest pakietem samodzielnym) to można go użyć z Django bez żadnego problemu. Jednak w niektórych sytuacjach brakuje mi pola typu ModelChoice, co utrudnia fabrykowanie instancji modeli. Z tego powodu zrobiłem poniższy snippet definiujący walidator ModelOneOf oraz klasę węzła ModelChoice. Jest na tyle przydatny, że postanowiłem się z nim podzielić jak najszybciej:

import colander
import types


class ModelOneOf(object):
    def __init__(self, qs):
        self._qs = qs

    def __call__(self, node, value):
        if not self._qs.filter(pk=value).exists():
            raise colander.Invalid(node, '%r is not valid choice' % value)


class ModelChoice(colander.SchemaType):
    def __init__(self, qs, *args, **kw):
        self._qs = qs
        self._model = qs.model
        self._validate = ModelOneOf(self._qs)

        super(ModelChoice, self).__init__(*args, **kw)

    def serialize(self, node, appstruct):
        if appstruct is colander.null:
            return colander.null
        if not isinstance(appstruct, self._model):
            raise colander.Invalid(
                    node, '%r is not a %s' % (appstruct, self._model))
        return appstruct.pk

    def deserialize(self, node, cstruct):
        if cstruct is colander.null:
            return colander.null
        if not isinstance(cstruct, (types.StringType, int)):
            raise colander.Invalid(
                    node, '%r is not a string nor int' % cstruct)

        self._validate(node, cstruct)
        return self._qs.get(pk=cstruct)

Przykładowe użycie (forms.py):

import colander
from .models import MyModel


class MySchema(colander.MappingSchema):
    model = colander.SchemaNode(ModelChoice(MyModel.objects.all()))

In [1]: s = MySchema()
In [2]: s.deserialize({'model': '1'})  # gdzie '1' to wartość PK
Out[2]: {'model': <MyModel pk=1>} 

Teraz zdeserializowane dane wejściowe da się wprost przekazać do fabryk lub konstruktora modeli, np:

instance = MyModel(**s.deserialize(...))

W ten sposób można całkowicie pominąć formularze django.