Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00279 005031 14830228 na godz. na dobę w sumie
Ciągłe dostarczanie oprogramowania. Automatyzacja kompilacji, testowania i wdrażania - ebook/pdf
Ciągłe dostarczanie oprogramowania. Automatyzacja kompilacji, testowania i wdrażania - ebook/pdf
Autor: , Liczba stron: 440
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-9921-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> techniki programowania
Porównaj ceny (książka, ebook, audiobook).

Dostarczaj oprogramowanie na zawołanie!

Jeśli Twoja praca wymaga, byś dostarczał oprogramowanie w sposób niemalże ciągły, a Ty chciałbyś uniknąć niepowodzeń, pomogą Ci w tym: automatyczna kompilacja, testowanie i wdrażanie. Dzięki nim możesz zaoferować użytkownikom aplikację najwyższej jakości w dowolnym czasie!

W tej książce znajdziesz instrukcje na temat realizacji takiego celu. Na samym początku poznasz typowe problemy z wdrażaniem oprogramowania, a w kolejnych rozdziałach zobaczysz, jak je rozwiązać. Zaczniesz od najlepszych technik zarządzania konfiguracją aplikacji, a następnie przejdziesz do zagadnień związanych z ciągłą integracją. Po tym wstępie czeka Cię niezwykle pasjonująca lektura dotycząca potoku wdrożeń oraz tworzenia skryptów automatyzujących proces tworzenia i budowania projektu. Ponadto zapoznasz się z detalami automatycznych testów akceptacyjnych i testów wymagań niefunkcjonalnych oraz zrozumiesz, jak stworzyć strategię udostępniania oprogramowania. Dla powodzenia całego przedsięwzięcia kluczowe jest zbudowanie ekosystemu wydawania oprogramowania. Ten temat został obszernie omówiony w trzeciej części książki. Jeżeli chcesz zmienić sposób wydawania Twojego oprogramowania, przeczytaj ten podręcznik!

Książka prezentuje: Wydawanie aplikacji jeszcze nigdy nie było tak proste!
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation Tłumaczenie: Dorota Konowrocka-Sawa ISBN: 978-83-246-9918-6 Authorized translation from the English language edition, entitled: CONTINUOUS DELIVERY: RELIABLE SOFTWARE RELEASES THROUGH BUILD, TEST, AND DEPLOYMENT AUTOMATION; ISBN 0321601912; by Jez Humble; and by David Farley; published by Pearson Education, Inc, publishing as Addison Wesley. Copyright © 2011 Pearson Education, Inc. All rights reserved. No part of this book may by reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc. Polish language edition published by HELION S.A. Copyright © 2015. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/cidoop Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści Przedmowa Martina Fowlera ......................................................................................................17 Wprowadzenie .............................................................................................................................19 Podziękowania .............................................................................................................................27 O autorach ....................................................................................................................................28 Część I. Podstawy ........................................................................................29 Rozdział 1. Problem dostarczania oprogramowania .................................................................31 Wstęp ..................................................................................................................................................... 31 Niektóre powszechnie występujące błędne wzorce wydawania oprogramowania .................... 32 Antywzorzec: ręczne wdrażanie oprogramowania ...................................................................33 Antywzorzec: wdrożenie w środowisku zbliżonym do środowiska produkcyjnego dopiero po zakończeniu programowania ...............................................................................35 Antywzorzec: ręczne zarządzanie konfiguracją środowiska produkcyjnego ..........................37 Czy możemy to poprawić? ..........................................................................................................38 Jak mamy osiągnąć nasz cel? .............................................................................................................. 39 Każda zmiana powinna uruchamiać proces pozyskiwania informacji zwrotnej ...................40 Informacja zwrotna musi być uzyskiwana możliwie szybko ...................................................41 Zespół odpowiedzialny za wdrożenie musi wyciągnąć praktyczne wnioski z otrzymanej informacji zwrotnej ..........................................................................................43 Czy ten proces się skaluje? ..........................................................................................................43 Jakie płyną z tego korzyści? ................................................................................................................ 44 Przyznanie zespołom większej władzy ......................................................................................44 Ograniczenie liczby błędów ........................................................................................................45 Obniżenie poziomu stresu ..........................................................................................................47 Elastyczność wdrożenia ..............................................................................................................47 Ćwiczenie czyni mistrza .............................................................................................................48 Kandydat do wydania .......................................................................................................................... 49 Każde zaewidencjonowanie prowadzi do potencjalnego wydania ..........................................50 Poleć książkęKup książkę 8 SPIS TREŚCI Zasady dostarczania oprogramowania ............................................................................................. 50 Stwórz powtarzalny, niezawodny proces dostarczania oprogramowania ..............................50 Automatyzuj, co tylko się da ......................................................................................................51 Przechowuj wszystko w systemie kontroli wersji ......................................................................51 Jeśli to boli, rób to częściej i szybciej zmierz się z bólem ...........................................................52 Wbuduj jakość w proces wytwarzania ......................................................................................52 Gotowe oznacza wydane ............................................................................................................53 Wszyscy są odpowiedzialni za udostępnianie oprogramowania .............................................53 Ciągłe doskonalenie ....................................................................................................................54 Podsumowanie ..................................................................................................................................... 54 Rozdział 2. Zarządzanie konfiguracją .........................................................................................57 Wstęp ..................................................................................................................................................... 57 Stosowanie systemów kontroli wersji ............................................................................................... 58 W systemie kontroli wersji przechowuj absolutnie wszystko ...................................................59 Wprowadzaj zmiany regularnie do głównej gałęzi projektu ...................................................61 Posługuj się czytelnymi opisami zakresu zmian .......................................................................62 Zarządzanie zależnościami ................................................................................................................. 63 Zarządzanie bibliotekami zewnętrznymi ..................................................................................63 Zarządzanie modułami ..............................................................................................................64 Zarządzanie konfiguracją oprogramowania .................................................................................... 64 Konfiguracja i elastyczność ........................................................................................................65 Typy konfiguracji ........................................................................................................................66 Zarządzanie konfiguracją aplikacji ...........................................................................................67 Zarządzanie konfiguracją szeregu aplikacji ..............................................................................70 Zasady zarządzania konfiguracją aplikacji ..............................................................................71 Zarządzanie środowiskami ................................................................................................................. 72 Narzędzia do zarządzania środowiskami .................................................................................75 Zarządzanie procesem zmiany ..................................................................................................75 Podsumowanie ..................................................................................................................................... 76 Rozdział 3. Ciągła integracja .......................................................................................................77 Wstęp ..................................................................................................................................................... 77 Wdrażanie ciągłej integracji ............................................................................................................... 78 Czego potrzebujesz na początek? ...............................................................................................78 Podstawowy system ciągłej integracji ........................................................................................79 Warunki wstępne ciągłej integracji ................................................................................................... 81 Ewidencjonuj regularnie ............................................................................................................81 Stwórz obszerny i kompleksowy zestaw zautomatyzowanych testów .....................................81 Niech proces kompilacji i testowania będzie możliwie krótki ..................................................82 Zarządzanie środowiskiem programistycznym ........................................................................83 Stosowanie systemów ciągłej integracji ............................................................................................ 84 Podstawowa funkcjonalność ......................................................................................................84 Wodotryski ..................................................................................................................................85 Poleć książkęKup książkę SPIS TREŚCI 9 Kluczowe praktyki ............................................................................................................................... 87 Nie ewidencjonuj niczego w popsutej kompilacji ......................................................................87 Zawsze testuj lokalnie wszystkie zmiany przed ich zatwierdzeniem albo zleć to serwerowi CI .........................................................................................................87 Zanim podejmiesz pracę, poczekaj na powodzenie testów towarzyszących przekazywaniu zmian ..................................................................................88 Nigdy nie idź do domu, dopóki kompilacja nie działa poprawnie ..........................................89 Zawsze bądź przygotowany na powrót do poprzednich wersji ................................................90 Ustaw sobie limit czasu na poprawki przed cofnięciem zmian ...............................................90 Nie wyłączaj testów, które zakończyły się niepowodzeniem ....................................................91 Weź odpowiedzialność za wszystkie szkody powstałe w wyniku zmian .................................91 Programowanie sterowane testami ............................................................................................91 Zalecane praktyki ................................................................................................................................. 92 Praktyki programowania ekstremalnego (XP) .........................................................................92 Odrzucanie kompilacji ze względu na naruszenie architektury ..............................................92 Odrzucanie kompilacji ze względu na powolność testów .........................................................93 Odrzucanie kompilacji ze względu na ostrzeżenia i niewłaściwe formatowania kodu .........94 Zespoły rozproszone ............................................................................................................................ 95 Wpływ na proces .........................................................................................................................95 Scentralizowana ciągła integracja .............................................................................................96 Problemy techniczne ...................................................................................................................97 Podejścia alternatywne ...............................................................................................................97 Rozproszone systemy kontroli wersji ............................................................................................... 99 Podsumowanie ...................................................................................................................................101 Rozdział 4. Wdrożenie strategii testów .....................................................................................103 Wstęp ...................................................................................................................................................103 Typy testów .........................................................................................................................................104 Testy biznesowe wspierające proces wytwarzania oprogramowania ....................................105 Testy technologiczne wspierające programowanie .................................................................108 Testy biznesowe umożliwiające krytyczną analizę projektu ..................................................108 Testy technologiczne umożliwiające krytyczną analizę projektu ..........................................110 Obiekty zastępcze ......................................................................................................................110 Sytuacje i strategie z prawdziwego życia .........................................................................................111 Na początku projektu ...............................................................................................................111 W środku projektu ....................................................................................................................112 Kod zastany ...............................................................................................................................113 Testy integracyjne .....................................................................................................................115 Proces ...................................................................................................................................................117 Zarządzanie zaległymi błędami ...............................................................................................118 Podsumowanie ...................................................................................................................................119 Poleć książkęKup książkę 10 SPIS TREŚCI Część II. Potok wdrożeń ...........................................................................121 Rozdział 5. Anatomia potoku wdrożeń .....................................................................................123 Wstęp ...................................................................................................................................................123 Czym jest potok wdrożeń? ................................................................................................................124 Podstawowy potok wdrożeń .....................................................................................................128 Praktyki związane z potokiem wdrożeń .........................................................................................130 Kompiluj binaria tylko raz .......................................................................................................130 W każdym środowisku wdrażaj w taki sam sposób ...............................................................132 Testuj wdrożenia testami dymnymi ........................................................................................134 Wdrażaj na kopii środowiska produkcyjnego .........................................................................134 Każda zmiana powinna być natychmiast przekazywana do kolejnej fazy potoku ..............135 Jeśli jakakolwiek część potoku nie działa, zatrzymaj potok ...................................................136 Faza przekazywania zmian ...............................................................................................................136 Najlepsze praktyki fazy przekazywania zmian .......................................................................138 Bramka automatycznych testów akceptacyjnych ..........................................................................139 Najlepsze praktyki fazy zautomatyzowanych testów akceptacyjnych ...................................141 Kolejne fazy testowania .....................................................................................................................142 Testy ręczne ...............................................................................................................................143 Testy niefunkcjonalne ...............................................................................................................144 Przygotowanie do wydania ...............................................................................................................144 Automatyzacja wdrożenia i wydania ......................................................................................145 Wycofywanie się ze zmian ........................................................................................................147 Budowanie na sukcesie .............................................................................................................148 Implementacja potoku wdrożeń ......................................................................................................148 Tworzenie modelu strumienia wartości i szkieletu systemu ..................................................148 Automatyzacja procesu kompilacji i wdrażania ....................................................................149 Automatyzacja testów jednostkowych i analiza kodu ...........................................................150 Automatyzacja testów akceptacyjnych ....................................................................................151 Rozwijanie potoku ....................................................................................................................151 Miary ....................................................................................................................................................152 Podsumowanie ...................................................................................................................................155 Rozdział 6. Skrypty kompilacji i wdrożenia ..............................................................................157 Wstęp ...................................................................................................................................................157 Przegląd narzędzi kompilacji ...........................................................................................................158 Make ..........................................................................................................................................160 Ant .............................................................................................................................................161 NAnt i MSBuild ........................................................................................................................162 Maven ........................................................................................................................................162 Rake ...........................................................................................................................................163 Buildr .........................................................................................................................................164 Psake ..........................................................................................................................................164 Poleć książkęKup książkę SPIS TREŚCI 11 Reguły i praktyki pisania skryptów kompilacji i wdrożenia ........................................................165 Stwórz skrypt dla każdej fazy potoku wdrożeń .......................................................................165 Zastosuj właściwą technologię do wdrożenia aplikacji ..........................................................165 W każdym środowisku wdrażaj za pomocą tych samych skryptów ......................................166 Skorzystaj z systemu zarządzania pakietami systemu operacyjnego ....................................167 Zapewnij idempotentność procesu wdrożenia ........................................................................168 Rozwijaj system wdrożeniowy przyrostowo ............................................................................169 Struktura projektu dla aplikacji, których celem jest wirtualna maszyna Javy ...........................170 Układ projektu ..........................................................................................................................170 Tworzenie skryptów wdrożenia .......................................................................................................173 Wdrażanie i testowanie warstw ...............................................................................................174 Testowanie konfiguracji środowiska ........................................................................................175 Rady i wskazówki ...............................................................................................................................176 Zawsze stosuj ścieżki względne ................................................................................................176 Wyeliminuj etapy ręczne ..........................................................................................................177 Wbuduj możliwość prześledzenia drogi od binariów do systemu kontroli wersji ................177 Nie ewidencjonuj binariów w systemie kontroli wersji jako części kompilacji .....................178 Cele testowe nie powinny eliminować kompilacji ..................................................................178 Ogranicz aplikację za pomocą zintegrowanych testów dymnych ..........................................179 Porady i wskazówki dotyczące .NET .......................................................................................179 Podsumowanie ...................................................................................................................................179 Rozdział 7. Faza przekazywania zmian .....................................................................................181 Wstęp ...................................................................................................................................................181 Zasady i praktyki fazy przekazywania zmian .................................................................................182 Dostarczaj szybkiej i użytecznej informacji zwrotnej .............................................................182 Co powinno przerywać fazę przekazywania zmian? ..............................................................184 Nadzoruj uważnie fazę przekazywania zmian .......................................................................184 Przekaż odpowiedzialność programistom ...............................................................................185 W bardzo dużych zespołach przypisz komuś funkcję mistrza kompilacji ............................186 Wyniki fazy przekazywania zmian ..................................................................................................186 Repozytorium artefaktów .........................................................................................................186 Zasady i praktyki dotyczące zestawu testów fazy przekazywania zmian ...................................189 Unikaj interfejsu użytkownika .................................................................................................190 Stosuj wstrzykiwanie zależności ..............................................................................................190 Unikaj bazy danych ..................................................................................................................190 Przy testach jednostkowych unikaj asynchroniczności ..........................................................191 Wykorzystywanie obiektów zastępczych .................................................................................191 Minimalizacja stanu w testach ................................................................................................194 Pozorowanie czasu ....................................................................................................................195 Nic na siłę ..................................................................................................................................195 Podsumowanie ...................................................................................................................................196 Poleć książkęKup książkę 12 SPIS TREŚCI Rozdział 8. Zautomatyzowane testy akceptacyjne ....................................................................197 Wstęp ...................................................................................................................................................197 Dlaczego zautomatyzowane testy akceptacyjne są tak ważne? ....................................................198 Jak tworzyć zestawy poddających się utrzymaniu testów akceptacyjnych? ..........................200 Testowanie graficznego interfejsu użytkownika .....................................................................202 Tworzenie testów akceptacyjnych ...................................................................................................203 Rola analityków i testerów .......................................................................................................203 Analiza w projektach iteracyjnych ..........................................................................................203 Kryteria akceptacyjne jako wykonywalne specyfikacje ..........................................................204 Warstwa sterownika aplikacji ..........................................................................................................207 Jak wyrażać swoje kryteria akceptacyjne? ...............................................................................209 Wzorzec sterownika okna: uniezależnianie testów od GUI ...................................................210 Implementacja testów akceptacyjnych ........................................................................................... 212 Stan w testach akceptacyjnych .................................................................................................212 Ograniczenia procesu, hermetyzacja i testowanie ..................................................................214 Zarządzanie asynchronicznością i przekroczeniem czasu przyznanego na daną operację ...215 Stosowanie obiektów zastępczych ............................................................................................217 Faza testów akceptacyjnych ..............................................................................................................220 Utrzymywanie poprawności testów akceptacyjnych ..............................................................221 Testy wdrożenia ........................................................................................................................223 Wydajność testów akceptacyjnych ..................................................................................................225 Refaktoryzacja często wykonywanych zadań ..........................................................................225 Współdziel kosztowne zasoby ..................................................................................................226 Testowanie równoległe .............................................................................................................227 Stosowanie przetwarzania rozproszonego ..............................................................................227 Podsumowanie ...................................................................................................................................229 Rozdział 9. Testowanie wymagań niefunkcjonalnych ..............................................................231 Wstęp ...................................................................................................................................................231 Zarządzanie wymaganiami niefunkcjonalnymi ............................................................................232 Analiza wymagań niefunkcjonalnych .....................................................................................233 Programowanie z myślą o wydajności ............................................................................................234 Pomiar wydajności .............................................................................................................................236 Jak definiować sukces i porażkę w testach wydajnościowych? ...............................................238 Środowisko testów wydajnościowych ............................................................................................. 239 Automatyzacja testów wydajnościowych .......................................................................................243 Testowanie wydajności poprzez interfejs użytkownika ..........................................................245 Nagrywanie interakcji przez usługę lub publiczne API ..........................................................246 Stosowanie szablonów nagranych interakcji ..........................................................................246 Stosowanie stubów testów wydajnościowych do produkcji testów ........................................248 Dodawanie testów wydajnościowych do potoku wdrożeń ..........................................................249 Dodatkowe korzyści płynące z systemu testów wydajnościowych .............................................251 Podsumowanie ...................................................................................................................................252 Poleć książkęKup książkę SPIS TREŚCI 13 Rozdział 10. Wdrażanie i wydawanie aplikacji .........................................................................253 Wstęp ...................................................................................................................................................253 Tworzenie strategii udostępniania oprogramowania ...................................................................254 Plan wydania ............................................................................................................................255 Udostępnianie produktów użytkownikom ..............................................................................256 Wdrażanie i promocja aplikacji .......................................................................................................256 Pierwsze wdrożenie ...................................................................................................................256 Szkicowanie procesu udostępniania oprogramowania i promowania kompilacji ...............257 Promocja konfiguracji ..............................................................................................................260 Orkiestracja ...............................................................................................................................260 Wdrożenia w środowiskach tymczasowych ............................................................................261 Wycofywanie się z wdrożeń i wydania bez przestojów ................................................................262 Wycofywanie się poprzez powtórne wdrożenie wcześniejszej dobrej wersji .........................262 Wydanie bez przestoju ..............................................................................................................263 Wdrożenia niebiesko-zielone ...................................................................................................263 Wydanie kanarkowe .................................................................................................................265 Poprawki awaryjne ............................................................................................................................267 Ciągłe wdrażanie ................................................................................................................................268 Ciągłe udostępnianie oprogramowania instalowanego przez użytkownika .........................269 Rady i wskazówki ...............................................................................................................................271 Ludzie odpowiedzialni za wdrożenie powinni być zaangażowani w tworzenie procesu wdrożenia .................................................................................................................271 Loguj działania związane z wdrożeniem ................................................................................272 Nie kasuj starych plików, tylko je przenieś ..............................................................................272 Za wdrożenie odpowiada cały zespół ......................................................................................273 Aplikacje serwerowe nie powinny mieć interfejsu graficznego ..............................................273 Przy nowym wdrożeniu pamiętaj o rozgrzewce ......................................................................273 Szybko odrzucaj błędne wersje .................................................................................................274 Nie dokonuj zmian bezpośrednio w środowisku produkcyjnym ...........................................274 Podsumowanie ...................................................................................................................................274 Część III. Ekosystem dostarczania oprogramowania ..............................277 Rozdział 11. Zarządzanie środowiskami i infrastrukturą ........................................................279 Wstęp ...................................................................................................................................................279 Rozumienie potrzeb zespołu eksploatacji systemów IT ...............................................................281 Dokumentacja i audyt ..............................................................................................................282 Ostrzeżenia o nienormalnych zdarzeniach .............................................................................282 Planowanie ciągłości dostarczania usług IT ...........................................................................283 Korzystaj z technologii znanej zespołowi eksploatacji systemów IT .....................................284 Opracowywanie modelu infrastruktury i zarządzanie nią ...........................................................284 Kontrola dostępu do infrastruktury .........................................................................................286 Wprowadzanie zmian w infrastrukturze ................................................................................287 Poleć książkęKup książkę 14 SPIS TREŚCI Zarządzanie dostarczaniem i konfiguracją serwerów ...................................................................288 Dostarczanie serwerów .............................................................................................................289 Bieżące zarządzanie serwerami ...............................................................................................290 Zarządzanie konfiguracją middleware’u ........................................................................................295 Zarządzanie konfiguracją ........................................................................................................295 Zbadaj produkt .........................................................................................................................297 Przeanalizuj, w jaki sposób middleware obsługuje stan ........................................................298 Poszukaj API konfiguracji ........................................................................................................298 Zastosuj lepszą technologię .......................................................................................................299 Zarządzanie usługami infrastrukturalnymi ...................................................................................299 Systemy wieloadresowe .............................................................................................................300 Wirtualizacja .......................................................................................................................................301 Zarządzanie środowiskami wirtualnymi ................................................................................303 Środowiska wirtualne i potok wdrożeń ...................................................................................305 Wysoce równoległe testowanie ze środowiskami wirtualnymi ..............................................307 Przetwarzanie w chmurze .................................................................................................................309 Infrastruktura w chmurze ........................................................................................................310 Platformy w chmurze ................................................................................................................311 Jedno rozwiązanie nie musi być odpowiednie dla wszystkich ...............................................312 Krytyka przetwarzania w chmurze .........................................................................................312 Monitorowanie infrastruktury i aplikacji .......................................................................................313 Gromadzenie danych ................................................................................................................314 Rejestrowanie zdarzeń ..............................................................................................................315 Tworzenie tablic wskaźników ..................................................................................................316 Monitoring sterowany zachowaniami .....................................................................................318 Podsumowanie ...................................................................................................................................318 Rozdział 12. Zarządzanie danymi .............................................................................................321 Wstęp ...................................................................................................................................................321 Pisanie skryptów baz danych ...........................................................................................................322 Inicjalizacja baz danych ...........................................................................................................322 Zmiana przyrostowa ..........................................................................................................................323 Wersjonowanie bazy danych ...................................................................................................323 Zarządzanie zharmonizowanymi zmianami .........................................................................325 Wycofywanie się do poprzedniej wersji baz danych i wydania bez przestojów .......................326 Wycofywanie się bez utraty danych ........................................................................................327 Uniezależnianie wdrożenia aplikacji od migracji bazy danych ............................................328 Zarządzanie danymi testowymi .......................................................................................................329 Imitowanie bazy danych na potrzeby testów jednostkowych ................................................330 Zarządzanie zależnościami między testami a danymi ..........................................................331 Izolacja testu .............................................................................................................................331 Przygotowanie i rozmontowanie .............................................................................................332 Spójne scenariusze testowe .......................................................................................................332 Poleć książkęKup książkę SPIS TREŚCI 15 Zarządzanie danymi i potok wdrożeń .............................................................................................333 Dane w fazie przekazywania zmian ........................................................................................333 Dane w testach akceptacyjnych ................................................................................................334 Dane w testach wydajnościowych ............................................................................................335 Dane w innych fazach testów ...................................................................................................336 Podsumowanie ...................................................................................................................................337 Rozdział 13. Zarządzanie modułami i zależnościami ..............................................................339 Wstęp ...................................................................................................................................................339 Utrzymywanie aplikacji w stanie zdatności do wydania ..............................................................340 Ukryj nową funkcjonalność, dopóki nie zostanie ukończona ................................................341 Wprowadzaj wszystkie zmiany przyrostowo ..........................................................................343 Rozgałęzianie przez abstrakcję ................................................................................................343 Zależności ............................................................................................................................................345 Piekło zależności .......................................................................................................................346 Zarządzanie bibliotekami ........................................................................................................347 Moduły ................................................................................................................................................349 Jak dzielić bazę kodu na moduły? ............................................................................................349 Droga modułów przez potok wdrożeń .....................................................................................352 Potok integracyjny ....................................................................................................................353 Zarządzanie schematem zależności .................................................................................................355 Tworzenie schematów zależności .............................................................................................355 Potokowanie schematów zależności ........................................................................................357 Kiedy powinniśmy wyzwalać kompilacje? ..............................................................................360 Ostrożny optymizm ..................................................................................................................360 Zależności cykliczne ..................................................................................................................362 Zarządzanie binariami .......................................................................................................................363 Jak powinno działać repozytorium artefaktów? .....................................................................363 W jaki sposób potok wdrożeń powinien współdziałać z repozytorium artefaktów? ............364 Zarządzanie zależnościami za pomocą Mavena ............................................................................365 Refaktoryzacja zależności Mavena ..........................................................................................367 Podsumowanie ...................................................................................................................................368 Rozdział 14. Zaawansowana kontrola wersji ............................................................................369 Wstęp ...................................................................................................................................................369 Krótka historia kontroli wersji .........................................................................................................370 CVS ............................................................................................................................................370 Subversion .................................................................................................................................371 Komercyjne systemy kontroli wersji ........................................................................................373 Wyłącz pesymistyczne blokowanie ..........................................................................................373 Rozgałęzianie i scalanie .....................................................................................................................375 Scalanie ......................................................................................................................................376 Gałęzie, strumienie i ciągła integracja ....................................................................................377 Poleć książkęKup książkę 16 SPIS TREŚCI Rozproszone systemy kontroli wersji .............................................................................................380 Czym jest rozproszony system kontroli wersji? .......................................................................380 Krótka historia rozproszonego systemu kontroli wersji .........................................................382 Rozproszone systemy kontroli wersji w środowiskach korporacyjnych .................................382 Korzystanie z rozproszonych systemów kontroli wersji .........................................................383 Strumieniowe systemy kontroli wersji ............................................................................................385 Czym są strumieniowe systemy kontroli wersji? .....................................................................385 Modele wytwarzania oprogramowania z wykorzystaniem strumieni ..................................387 Widoki statyczne i dynamiczne ...............................................................................................389 Ciągła integracja z systemami kontroli wersji opartymi na strumieniach ...........................389 Programuj na gałęzi głównej projektu ............................................................................................390 Dokonywanie złożonych zmian bez rozgałęziania .................................................................391 Gałąź na potrzeby wydania ...............................................................................................................393 Rozgałęzienia według kryterium funkcji ........................................................................................ 394 Rozgałęzianie pod kątem zespołu ....................................................................................................397 Podsumowanie ...................................................................................................................................400 Rozdział 15. Zarządzanie ciągłym dostarczaniem oprogramowania ......................................403 Wstęp ...................................................................................................................................................403 Model dojrzałości zarządzania konfiguracją i wydaniami ...........................................................405 Jak posługiwać się modelem dojrzałości405 Cykl życia projektu ............................................................................................................................407 Identyfikacja ..............................................................................................................................408 Zapoczątkowywanie .................................................................................................................409 Inicjalizacja ...............................................................................................................................410 Wytwarzanie i wdrażanie ........................................................................................................411 Eksploatacja ..............................................................................................................................414 Proces zarządzania ryzykiem ...........................................................................................................414 Podstawy zarządzania ryzykiem ..............................................................................................415 Harmonogram zarządzania ryzykiem ....................................................................................415 Jak wykonać ćwiczenie z zakresu zarządzania ryzykiem? .....................................................416 Częste problemy z dostarczaniem oprogramowania — objawy i przyczyny ............................417 Rzadkie lub wadliwe wdrożenia ..............................................................................................418 Kiepska jakość aplikacji ............................................................................................................418 Kiepsko zarządzany proces ciągłej integracji ..........................................................................420 Słabe zarządzanie konfiguracją ...............................................................................................420 Zgodność z regulacjami i audyt .......................................................................................................421 Przewaga automatyzacji nad dokumentacją ..........................................................................422 Narzucanie możliwości śledzenia zmian .................................................................................422 Praca w silosach ........................................................................................................................423 Zarządzanie zmianą .................................................................................................................424 Podsumowanie ...................................................................................................................................425 Bibliografia .................................................................................................................................427 Skorowidz ...................................................................................................................................429 Poleć książkęKup książkę Rozdział 3 Ciągła integracja Wstęp Niezmiernie dziwną, ale powszechnie spotykaną cechą wielu projektów programistycznych jest to, że na przestrzeni długich okresów procesu rozwojowego aplikacja w ogóle nie działa. W gruncie rzeczy większość oprogramowania wytwarzanego przez duże zespoły nie nadaje się do użycia przez znaczną część czasu przeznaczonego na jego rozwój. Powody nietrudno zrozumieć: nikt nie jest zainteresowany podjęciem prób uruchomienia całej aplikacji, dopóki nie zostanie ukończona. Programiści ewidencjonują zmiany i być może nawet przeprowadzają zautomatyzowane testy jednostkowe, ale nikt nie próbuje tak naprawdę uruchomić całej apli- kacji i posłużyć się nią w środowisku zbliżonym do produkcyjnego. Dzieje się tak zwłaszcza w projektach, w których od dawna funkcjonują oddzielne gałęzie lub w których testy akceptacyjne odkładane są na sam koniec. W wielu takich projektach na koniec fazy rozwoju zaplanowano długotrwałą fazę integracji pozostawiającą zespołowi pro- jektowemu czas na scalenie gałęzi i uruchomienie całości aplikacji, by mogła przejść testy ak- ceptacyjne. Co gorsza, w niektórych projektach okazuje się, że kiedy dochodzi się już do tej fazy, oprogramowanie nie realizuje postawionych przed nim zadań. Integracja może się okazać nie- zwykle czasochłonna, a co najgorsze, nie sposób przewidzieć, ile to wszystko ostatecznie potrwa. Z drugiej strony zetknęliśmy się też z projektami, w których aplikacja po wprowadzeniu najnowszych zmian nie działa zaledwie przez kilka minut. Różnica polega na zastosowaniu ciągłej integracji. Ciągła integracja wymaga, by za każdym razem, gdy ktoś ewidencjonuje ja- kąkolwiek zmianę, cała aplikacja została skompilowana i poddana wszechstronnym testom zautomatyzowanym. Zasadnicze znaczenie ma to, by w sytuacji, kiedy proces kompilacji lub testów nie powiedzie się, zespół projektowy przerwał to, czym w danym momencie się zajmuje, i natychmiast rozwiązał powstały problem. Celem ciągłej integracji jest stała dostępność działa- jącego oprogramowania. O ciągłej integracji po raz pierwszy napisał Kent Beck w książce Extreme Programming Explained (pierwsze wydanie w 1999 roku). Podobnie jak w przypadku innych praktyk pro- gramowania ekstremalnego, u podstaw ciągłej integracji leży następująca konstatacja: jeśli re- gularna integracja bazy kodu jest dobra, to dlaczego nie robić tego ciągle? W kontekście inte- gracji „ciągle” oznacza „za każdym razem, gdy ktokolwiek zaewidencjonuje jakąkolwiek zmianę w systemie kontroli wersji”. Jak mówi Mike Roberts, jeden z naszych współpracowników, „»ciągle« to częściej, niż myślisz” [aEu8Nu]. Poleć książkęKup książkę 78 ROZDZIAŁ 3. CIĄGŁA INTEGRACJA Ciągła integracja stanowi zmianę paradygmatu. Bez ciągłej integracji oprogramowanie nie działa, dopóki ktoś nie udowodni, że jest inaczej — zazwyczaj na etapie testów lub integracji. Przy ciągłej integracji oprogramowanie w sposób udowodniony działa (zakładając wystar- czająco wszechstronny i kompleksowy zestaw zautomatyzowanych testów) po każdej nowej zmianie. Wiesz doskonale, w którym momencie przestaje działać, i możesz to naprawić. Zespoły, które w efektywny sposób posługują się ciągłą integracją, są w stanie dostarczać oprogramo- wanie znacznie szybciej i z mniejszą ilością błędów niż zespoły niestosujące ciągłej integracji. Błędy wychwytywane są na znacznie wcześniejszych etapach procesu projektowego, a tym samym ich poprawienie jest tańsze, co pociąga za sobą oszczędność czasu i pieniędzy. Z tego względu uznajemy ciągłą integrację za kluczową praktykę stosowaną w profesjonalnych ze- społach, być może równie istotną jak stosowanie systemu kontroli wersji. W pozostałej części tego rozdziału opisujemy metody wdrażania ciągłej integracji. Wyjaśni- my, jak rozwiązać powszechnie występujące problemy pojawiające się wraz ze wzrostem złożo- ności projektu, i wyliczymy praktyki skutecznie wspierające ciągłą integrację oraz ich wpływ na proces projektowania i wytwarzania oprogramowania. Omówimy również bardziej zaawan- sowane tematy, w tym metody wprowadzania ciągłej integracji w zespołach rozproszonych. Ciągła integracja omówiona jest obszernie w książce Paula Duvalla Continuous Integration (Addison-Wesley, 2006), którą można uznać za komplementarną wobec niniejszej. Jeśli szukasz bardziej szczegółowego omówienia ciągłej integracji niż zaproponowane przez nas w tym roz- dziale, znajdziesz je właśnie w książce Duvalla. Rozdział ten skierowany jest głównie do programistów. Zawiera jednak również nieco informacji, które naszym zdaniem przydadzą się menedżerom projektów chcącym poszerzyć swoją wiedzę o praktycznych aspektach ciągłej integracji. Wdrażanie ciągłej integracji Praktyka ciągłej integracji zależy od spełnienia pewnych warunków wstępnych. Omówimy je, a następnie przyjrzymy się dostępnym narzędziom. Być może najbardziej istotne jest to, że ciągła integracja zależy od tego, czy zespół postępuje zgodnie z kilkoma kluczowymi proce- durami, więc poświęcimy chwilę na ich omówienie. Czego potrzebujesz na początek? Przed rozpoczęciem ciągłej integracji potrzebujesz trzech elementów. 1. Kontrola wersji Wszystkie elementy projektu muszą zostać zaewidencjonowane w jednym repozytorium kon- troli wersji: kody, testy, skrypty baz danych, skrypty kompilacji i wdrożenia i cała reszta, której potrzebujesz, by stworzyć, zainstalować, uruchomić i przetestować aplikację. Może się to wyda- wać oczywiste, ale ku naszemu zaskoczeniu istnieją jeszcze projekty, w których nie jest stoso- wany żaden system kontroli wersji. Niektórzy sądzą, że rozmiar ich projektów nie uzasadnia wprowadzenia systemu kontroli wersji. My natomiast jesteśmy przekonani, że nie istnieją pro- jekty na tyle małe, by móc się bez niego obejść. Nawet gdy samodzielnie piszemy kod — na własne potrzeby i na własnym komputerze — to i tak stosujemy kontrolę wersji. Istnieje kilka prostych, lekkich i darmowych, a jednocześnie posiadających duże możliwości systemów kontroli wersji. Dostępne systemy kontroli zmian i ich zastosowanie opisujemy szczegółowo w sekcji „Stosowanie systemów kontroli wersji” w rozdziale 2., a także w rozdziale 14., „Zaawansowana kontrola wersji”. Poleć książkęKup książkę WDRAŻANIE CIĄGŁEJ INTEGRACJI 79 2. Automatyczna kompilacja Musisz być w stanie uruchomić kompilację z wiersza poleceń. Możesz zacząć od programu wiersza poleceń, który każe Twojemu IDE skompilować oprogramowanie, a następnie prze- prowadzić testy, ale może to być również złożony zbiór wieloetapowych skryptów kompilacji wywołujących się po kolei. Niezależnie od tego, jak będzie wyglądał ostateczny mechanizm, człowiek lub komputer muszą mieć możliwość przeprowadzenia procesu kompilacji, testów i wdrożenia w sposób zautomatyzowany za pomocą wiersza poleceń. Narzędzia IDE i narzędzia ciągłej integracji są współcześnie dość wyszukane i zazwyczaj możesz skompilować oprogramowanie i przeprowadzić testy, nie zbliżając się nawet do wiersza poleceń. Sądzimy jednak, że mimo to powinieneś mieć skrypty kompilacji możliwe do uru- chomienia z wiersza poleceń bez sięgania po IDE. Może się to wydawać kontrowersyjne, ale wynika z kilku przyczyn: (cid:374) Musisz być w stanie uruchomić swój proces kompilacji w sposób zautomatyzowany z wła- snego środowiska ciągłej integracji, aby mógł zostać poddany audytowi, gdy coś pójdzie nie tak. (cid:374) Skrypty kompilacji powinny być traktowane jak baza kodu. Powinny być testowane i usta- wicznie refaktoryzowane, aby były uporządkowane i czytelne. Nie da się tego zrobić, kiedy proces kompilacji przeprowadzany jest za pomocą narzędzi IDE. Im bardziej złożone stają się Twoje projekty, tym większego nabiera to znaczenia. (cid:374) Ułatwia to zrozumienie kompilacji, utrzymanie i debugowanie kompilacji; pozwala również na lepszą współpracę z pracownikami działu eksploatacji systemów IT. 3. Zgoda zespołu Ciągła integracja jest procedurą, nie narzędziem. Wymaga od zespołu programistycznego pewnego zaangażowania i dyscypliny. Wszyscy muszą często ewidencjonować w głównej ga- łęzi projektu małe, inkrementalne zmiany i zgodzić się co do tego, że zadaniem o najwyższym priorytecie w projekcie jest poprawienie każdej zmiany psującej aplikację. Jeśli ludzie nie na- rzucą sobie koniecznej do osiągnięcia tego celu dyscypliny, próba wprowadzenia ciągłej inte- gracji nie doprowadzi do oczekiwanego podniesienia jakości. Podstawowy system ciągłej integracji Nie potrzebujesz systemu ciągłej integracji, by prowadzić ciągłą integrację — jak już powiedzie- liśmy, jest to procedura, a nie narzędzie. James Shore opisuje najprostszą metodę rozpoczęcia ciągłej integracji w artykule pod tytułem Continuous Integration on a Dollar a Day [bAJpjp] za pomocą jedynie niewykorzystywanej stacji roboczej, gumowego kurczaka i dzwonka sta- wianego zazwyczaj na kontuarze hotelowej recepcji. Warto przeczytać ten artykuł, bo cu- downie pokazuje podstawy ciągłej integracji bez stosowania jakichkolwiek narzędzi z wyjątkiem systemu kontroli wersji. W rzeczywistości jednak współczesne narzędzia ciągłej integracji niezwykle łatwo jest zain- stalować i uruchomić. Istnieje kilka opcji open source, takich jak Hudson i czcigodna rodzina CruiseControl (CruiseControl, CruiseControl.NET i CruiseControl.rb). Hudsona, a już zwłasz- cza CruiseControl.rb niezwykle łatwo jest postawić i uruchomić. CruiseControl.rb jest bardzo lekki i może być bez trudu rozszerzany przez każdego, kto dysponuje choćby niewielką wiedzą na temat Ruby. Hudson ma ogromny zestaw wtyczek pozwalających na integrację z dosłownie każdym narzędziem w ekosystemie kompilacji i wdrożenia. Poleć książkęKup książkę 80 ROZDZIAŁ 3. CIĄGŁA INTEGRACJA W chwili pisania tej książki dwa komercyjne serwery ciągłej integracji mają wersje darmowe zaprojektowane dla małych zespołów: Go wydawany przez ThoughtWorks Studios i TeamCity autorstwa JetBrains. Inne popularne komercyjne serwery CI to między innymi Bamboo au- torstwa Atlassian i Pulse stworzony przez Zutubi. Wysokiej klasy systemy zarządzania wyda- niami i przyspieszania kompilacji, które można stosować również w celu zwykłej ciągłej inte- gracji, to między innymi AntHillPro produkcji UrbanCode1, ElectricCommander produkcji Electric Cloud i Rational BuildForge produkcji IBM. Istnieje wiele innych systemów; pełną listę znajdziesz w macierzy funkc
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Ciągłe dostarczanie oprogramowania. Automatyzacja kompilacji, testowania i wdrażania
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: