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

 
Ciągłe dostarczanie oprogramowania. Automatyzacja kompilacji, testowania i wdrażania
Zawiera darmowych rozdziałów: 35
Stron w książce: 440 Udostępniono darmowych stron: 26
Data wydania: 2015-01-21Przejdź na stronę księgarni
Czytano online: 1Cena książki drukowanej: 69,00 zł
Język wydania: PolishWydawnictwo: Helion
Pobierz pdfCzytaj Alt+1Czytaj online
( Alt+1 )

Wydawanie aplikacji jeszcze nigdy nie było tak proste!

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, jak zrealizować ten cel. 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!

Dzięki tej książce:

  • poznasz najczęstsze problemy występujące podczas wdrażania oprogramowania
  • zobaczysz, jak automatyzować poszczególne etapy tworzenia oprogramowania
  • zbudujesz doskonały ekosystem wydawania oprogramowania
  • wydasz Twoją aplikację

...

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)

Informatyka » Techniki programowania

https://facebook.com/wiedzanaplus
Alt + 9
Pomoc ( Alt + 0 )
Loading...