Dostarczaj oprogramowanie na zawołanie!

• 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

Rozdziały:

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)