Ciągłe dostarczanie oprogramowania. Automatyzacja kompilacji, testowania i wdrażania - ebook
Ciągłe dostarczanie oprogramowania. Automatyzacja kompilacji, testowania i wdrażania - ebook
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:
- Automatyzację wszystkich aspektów kompilacji, integracji, testowania i wdrażania oprogramowania
- Implementację potoków wdrożeń na poziomie zespołu projektowego i organizacji
- Usprawnienie współpracy programistów, testerów i pracowników odpowiedzialnych za eksploatację oprogramowania
- Przyrostowy rozwój funcjonalności w dużych i rozproszonych zespołach
- Wdrożenie skutecznej strategii zarządzania konfiguracją
- Automatyzację testów akceptacyjnych od analizy do implementacji
- Testowanie wydajności i innych wymagań niefunkcjonalnych
- Implementację ciągłego wdrażania i wydań bez przestojów
- Zarządzanie infrastrukturą, danymi, modułami i zależnościami
- Rozwiązywanie kwestii zarządzania ryzykiem, zgodności z regulacjami i audytu
Wydawanie aplikacji jeszcze nigdy nie było tak proste!
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)
- 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)
- 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)
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)
- 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)
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)
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)
- 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)
- 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)
- 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ści (405)
- 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)
Kategoria: | Programowanie |
Zabezpieczenie: |
Watermark
|
ISBN: | 978-83-246-9921-6 |
Rozmiar pliku: | 4,8 MB |