{"id":2189418,"date":"2026-04-16T04:31:36","date_gmt":"2026-04-16T02:31:36","guid":{"rendered":"https:\/\/academy.asseco.pl\/training\/default-layout-itil-4-foundation\/"},"modified":"2026-04-16T04:31:37","modified_gmt":"2026-04-16T02:31:37","slug":"designing-and-implementing-microsoft-devops-solutions","status":"publish","type":"training","link":"https:\/\/academy.asseco.pl\/en\/training\/designing-and-implementing-microsoft-devops-solutions\/","title":{"rendered":"Designing and Implementing Microsoft DevOps solutions"},"content":{"rendered":"
\n
\n
\n
\n
\n
\n
\n
\n
Asseco Academy<\/a><\/span><\/span><\/div>\n <\/div>\n<\/div> <\/div>\n
\n

Training AZ-400T00_AIO_Z<\/p>\n

Designing and Implementing Microsoft DevOps solutions<\/h2>
\n \n<\/div> <\/div>\n
\n
\n Rozwi\u0105zania IT<\/a>\n Microsoft<\/a>\n Infrastruktura i architektura Azure<\/a>\n DevOps<\/a>\n In\u017cynieria DevOps<\/a>\n Chmura obliczeniowa<\/a>\n Infrastruktura chmurowa<\/a>\n <\/div>\n <\/div>\n <\/div>\n
\n

Accreditation<\/p>\n

<\/div>\n <\/div>\n <\/div>\n <\/div>\n <\/div>\n<\/section>\n\n
\n
\n
\n
\n

Training<\/p>\n\n

Price of training from <\/strong> PLN\u00a03,150  net<\/sup><\/strong><\/p>\n\n

Lowest price in the last 30 days: PLN\u00a03,150  net<\/sup><\/strong><\/p>\n \n

Language: <\/strong>polski<\/p>\n

*the price depends, among others on the form of training and the date<\/p>\n

\n
Sign up<\/div>\n
Download PDF<\/div>\n <\/div>\n <\/div>\n
\n\n

Additional products<\/p>\n

No additional books have been specified for this training.<\/p>\n

Exam price <\/strong>from PLN\u00a00.01   net<\/sup><\/p>\n \n \n <\/div>\n <\/div>\n <\/div>\n<\/section>\n\n\n

\n
\n
\n
\n
    \n
  • Training description<\/li>\n
  • Scope<\/li>\n
  • Exam<\/li>\n <\/ul>\n <\/div>\n
    \n
    \n
    \n
    \n

    Training description<\/h2> <\/div>\n

    <\/p>\n

    Szkolenie jest przeznaczone dla inżynierów DevOps, którzy chcą opanować projektowanie i wdrażanie procesów DevOps w środowisku Microsoft Azure. Podczas szkolenia uczestnicy poznają kompleksowy zestaw praktyk i narzędzi obejmujących cały cykl życia oprogramowania — od planowania i kontroli wersji, przez ciągłą integrację i dostarczanie, aż po bezpieczeństwo, zarządzanie zależnościami i monitoring.<\/p>\n

    Szkolenie obejmuje zagadnienia dotyczące pracy z Git i Azure Repos, strategii branchowania i pull requestów, automatyzacji potoku CI\/CD za pomocą Azure Pipelines i GitHub Actions, konteneryzacji oraz strategii wdrożeń (blue-green, canary, A\/B). Uczestnicy nauczą się zarządzać infrastrukturą jako kodem z użyciem ARM, Bicep i Azure Automation, implementować praktyki DevSecOps oraz zarządzać pakietami i artefaktami za pomocą Azure Artifacts i GitHub Packages. Ostatnia część szkolenia poświęcona jest ciągłemu monitorowaniu i zbieraniu informacji zwrotnych z wykorzystaniem Azure Monitor, Application Insights i narzędzi do współdzielenia wiedzy w zespole.<\/p>\n

    Szkolenie przygotowuje do egzaminu certyfikacyjnego Microsoft Certified: DevOps Engineer Expert.<\/p>\n

    W trakcie szkolenia:<\/p>\n

      \n
    • nauczysz się projektować i wdrażać procesy ciągłej integracji i ciągłego dostarczania (CI\/CD) za pomocą Azure Pipelines i GitHub Actions<\/li>\n
    • poznasz strategie branchowania, zarządzania repozytoriami i współpracy z pull requestami na poziomie enterprise<\/li>\n
    • nauczysz się zarządzać infrastrukturą jako kodem z użyciem ARM, Bicep, Azure CLI i Desired State Configuration (DSC)<\/li>\n
    • poznasz praktyki DevSecOps, analizę składu oprogramowania i narzędzia do monitorowania bezpieczeństwa<\/li>\n
    • nauczysz się wdrażać zaawansowane wzorce wdrożeń: blue-green, canary, A\/B i progressive exposure<\/li>\n
    • nauczysz się implementować ciągły monitoring i zbieranie informacji zwrotnych za pomocą Azure Monitor i Application Insights<\/li>\n<\/ul>\n

       <\/p>\n

      Adresaci szkolenia:<\/strong><\/p>\n

      Podstawową grupę odbiorców stanowią inżynierowie DevOps odpowiedzialni za projektowanie i wdrażanie procesów DevOps w organizacji. Szkolenie jest również skierowane do administratorów i programistów, którzy chcą poszerzyć kompetencje w zakresie automatyzacji, bezpieczeństwa potoku i zarządzania infrastrukturą w środowisku Azure. Szkolenie przygotowuje do uzyskania certyfikacji Microsoft Certified: DevOps Engineer Expert.<\/p>\n

       <\/p>\n

      Wymagania wstępne:<\/strong><\/p>\n

        \n
      • Podstawowa znajomość Azure DevOps i GitHub.<\/li>\n
      • Znajomość pojęć z zakresu kontroli wersji, ciągłej integracji i ciągłego dostarczania.<\/li>\n
      • Doświadczenie z platformą Azure na poziomie co najmniej AZ-104 lub AZ-204 (bądź wiedza równoważna).<\/li>\n<\/ul>\n\n <\/div>\n
        \n
        \n

        Scope<\/h2> <\/div>\n

        <\/p>\n

          \n
        • Wprowadzenie do DevOps\n
            \n
          • Co to jest DevOps?<\/li>\n
          • Podróż DevOps<\/li>\n
          • Identyfikacja zespołów ds. transformacji DevOps<\/li>\n
          • Definiowanie struktury organizacyjnej dla praktyk Agile<\/li>\n
          • Określanie wspólnych celów i harmonogramów<\/li>\n
          • Co to jest Azure DevOps?<\/li>\n
          • Co to jest GitHub?<\/li>\n
          • Projektowanie strategii zarządzania licencjami<\/li>\n
          • Co to jest kontrola wersji?<\/li>\n
          • Praca z Git lokalnie<\/li>\n
          • Wprowadzenie do Azure Repos<\/li>\n
          • Wprowadzenie do GitHub<\/li>\n<\/ul>\n<\/li>\n
          • Planowanie Agile z GitHub Projects i Azure Boards\n
              \n
            • Wprowadzenie do GitHub Projects i tablic projektów<\/li>\n
            • Wprowadzenie do Azure Boards<\/li>\n
            • Konfigurowanie projektów i zespołów w Azure DevOps<\/li>\n
            • Łączenie GitHub z Azure Boards<\/li>\n
            • Konfigurowanie GitHub Projects<\/li>\n
            • Zarządzanie pracą za pomocą tablic GitHub Projects<\/li>\n
            • Dostosowywanie widoków projektów<\/li>\n
            • Współpraca z użyciem dyskusji zespołowych<\/li>\n
            • Projektowanie i wdrażanie strategii pętli informacji zwrotnych<\/li>\n
            • Projektowanie i wdrażanie śledzenia źródeł, błędów i jakości<\/li>\n
            • Ćwiczenie: zarządzanie planem i portfelem Agile za pomocą Azure Boards<\/li>\n<\/ul>\n<\/li>\n
            • Projektowanie i wdrażanie strategii branchowania i przepływów pracy\n
                \n
              • Typy przepływów pracy z branchami<\/li>\n
              • Feature branch workflow<\/li>\n
              • Model branchowania Git dla ciągłego dostarczania<\/li>\n
              • GitHub flow<\/li>\n
              • Fork workflow<\/li>\n
              • Implementacja ograniczeń scalania gałęzi<\/li>\n
              • Ćwiczenie: kontrola wersji z Git w Azure Repos<\/li>\n<\/ul>\n<\/li>\n
              • Współpraca z pull requestami w Azure Repos\n
                  \n
                • Współpraca z pull requestami<\/li>\n
                • Ćwiczenie: współpraca z pull requestami w Azure Repos<\/li>\n<\/ul>\n<\/li>\n
                • Git hooks\n
                    \n
                  • Wprowadzenie do Git hooks<\/li>\n
                  • Implementacja Git hooks<\/li>\n<\/ul>\n<\/li>\n
                  • Inner source\n
                      \n
                    • Inner source<\/li>\n
                    • Implementacja fork workflow<\/li>\n
                    • Inner source z użyciem forków<\/li>\n<\/ul>\n<\/li>\n
                    • Zarządzanie repozytoriami i ich konfigurowanie\n
                        \n
                      • Praca z dużymi repozytoriami<\/li>\n
                      • Monorepo a wiele repozytoriów<\/li>\n
                      • Implementacja changelogu<\/li>\n
                      • Implementacja Scalar i współdzielenie między repozytoriami<\/li>\n
                      • Odzyskiwanie danych za pomocą poleceń Git<\/li>\n
                      • Czyszczenie danych repozytorium<\/li>\n
                      • Zarządzanie wydaniami z użyciem GitHub Repos<\/li>\n
                      • Automatyzacja informacji o wydaniach w GitHub<\/li>\n
                      • Tworzenie dokumentacji API<\/li>\n
                      • Automatyzacja dokumentacji historii Git<\/li>\n
                      • Konfigurowanie uprawnień repozytorium w GitHub<\/li>\n
                      • Konfigurowanie tagów GitHub<\/li>\n<\/ul>\n<\/li>\n
                      • Identyfikacja długu technicznego\n
                          \n
                        • Jakość kodu<\/li>\n
                        • Metryki złożoności i jakości<\/li>\n
                        • Wprowadzenie do długu technicznego<\/li>\n
                        • Pomiar i zarządzanie długiem technicznym<\/li>\n
                        • Wprowadzenie do GitHub Advanced Security<\/li>\n
                        • Integracja narzędzi do jakości kodu<\/li>\n
                        • Planowanie efektywnych przeglądów kodu<\/li>\n<\/ul>\n<\/li>\n
                        • Azure Pipelines — wprowadzenie\n
                            \n
                          • Koncepcja potoków w DevOps<\/li>\n
                          • Opis Azure Pipelines<\/li>\n
                          • Kluczowe pojęcia Azure Pipelines<\/li>\n<\/ul>\n<\/li>\n
                          • Zarządzanie agentami i pulami agentów Azure Pipelines\n
                              \n
                            • Agenci hostowani przez Microsoft a agenci self-hosted<\/li>\n
                            • Typy zadań<\/li>\n
                            • Pule agentów<\/li>\n
                            • Predefiniowane pule agentów<\/li>\n
                            • Typowe scenariusze dla pul agentów<\/li>\n
                            • Komunikacja z Azure Pipelines<\/li>\n
                            • Komunikacja przy wdrożeniu na serwery docelowe<\/li>\n
                            • Bezpieczeństwo pul agentów<\/li>\n
                            • Ćwiczenie: konfigurowanie pul agentów i stylów potoku<\/li>\n<\/ul>\n<\/li>\n
                            • Potoki i współbieżność\n
                                \n
                              • Zadania równoległe<\/li>\n
                              • Szacowanie zadań równoległych<\/li>\n
                              • Azure Pipelines i projekty open source<\/li>\n
                              • Azure Pipelines i Visual Designer<\/li>\n
                              • Azure Pipelines i YAML<\/li>\n
                              • Włączanie ciągłej integracji za pomocą Azure Pipelines<\/li>\n<\/ul>\n<\/li>\n
                              • Projektowanie i wdrażanie strategii potoku\n
                                  \n
                                • Konfigurowanie wymagań agenta<\/li>\n
                                • Kompilacje z wieloma konfiguracjami i wieloma agentami<\/li>\n
                                • Integracja repozytoriów GitHub z Azure Pipelines<\/li>\n
                                • Projektowanie i wdrażanie kompleksowej strategii testowania<\/li>\n
                                • Implementacja pokrycia kodu i prezentacja w potoku<\/li>\n
                                • Kompilacje wielozadaniowe<\/li>\n
                                • Typy kontroli źródła obsługiwane przez Azure Pipelines<\/li>\n<\/ul>\n<\/li>\n
                                • Integracja z Azure Pipelines\n
                                    \n
                                  • Anatomia potoku<\/li>\n
                                  • Struktura potoku<\/li>\n
                                  • Szablony<\/li>\n
                                  • Zasoby YAML<\/li>\n
                                  • Używanie wielu repozytoriów w potoku<\/li>\n
                                  • Migracja potoku z klasycznego do YAML w Azure Pipelines<\/li>\n<\/ul>\n<\/li>\n
                                  • Wprowadzenie do GitHub Actions\n
                                      \n
                                    • Co to są akcje?<\/li>\n
                                    • Przepływ akcji<\/li>\n
                                    • Przepływy pracy (workflows)<\/li>\n
                                    • Elementy składni przepływu pracy<\/li>\n
                                    • Zdarzenia (events)<\/li>\n
                                    • Zadania (jobs)<\/li>\n
                                    • Mechanizmy uruchamiające (runners)<\/li>\n
                                    • Wydawanie i testowanie akcji<\/li>\n<\/ul>\n<\/li>\n
                                    • Ciągła integracja z GitHub Actions\n
                                        \n
                                      • Ciągła integracja z Actions<\/li>\n
                                      • Zmienne środowiskowe<\/li>\n
                                      • Współdzielenie artefaktów między zadaniami<\/li>\n
                                      • Odznaki przepływu pracy<\/li>\n
                                      • Najlepsze praktyki tworzenia akcji<\/li>\n
                                      • Oznaczanie wydań tagami Git<\/li>\n
                                      • Tworzenie zaszyfrowanych sekretów<\/li>\n
                                      • Używanie sekretów w przepływie pracy<\/li>\n
                                      • Ćwiczenie: implementacja GitHub Actions dla CI\/CD<\/li>\n<\/ul>\n<\/li>\n
                                      • Projektowanie strategii budowania kontenerów\n
                                          \n
                                        • Struktura kontenerów<\/li>\n
                                        • Praca z kontenerami Docker<\/li>\n
                                        • Podstawowe koncepcje Dockerfile<\/li>\n
                                        • Wieloetapowe pliki Dockerfile<\/li>\n
                                        • Zagadnienia dotyczące kompilacji wieloetapowych<\/li>\n
                                        • Usługi kontenerowe Azure<\/li>\n
                                        • Wdrażanie kontenerów Docker do Azure App Service<\/li>\n<\/ul>\n<\/li>\n
                                        • Tworzenie potoku wydania\n
                                            \n
                                          • Możliwości Azure Pipelines<\/li>\n
                                          • Potoki wydania<\/li>\n
                                          • Źródła artefaktów<\/li>\n
                                          • Wybór odpowiedniego źródła artefaktów<\/li>\n
                                          • Zagadnienia dotyczące wdrożenia do etapów<\/li>\n
                                          • Zadania kompilacji i wydania<\/li>\n
                                          • Niestandardowe zadania kompilacji i wydania<\/li>\n
                                          • Zadania wydania<\/li>\n
                                          • Zadania wdrożenia bazy danych<\/li>\n
                                          • Konfigurowanie potoków jako kodu w YAML<\/li>\n<\/ul>\n<\/li>\n
                                          • Rekomendacje dotyczące strategii wydania\n
                                              \n
                                            • Rytm dostarczania i trzy typy wyzwalaczy<\/li>\n
                                            • Zatwierdzenia wydania<\/li>\n
                                            • Bramki wydania<\/li>\n
                                            • Używanie bramek wydania do ochrony jakości<\/li>\n
                                            • Strategia wydania GitOps<\/li>\n
                                            • Ćwiczenie: kontrolowanie wdrożeń za pomocą bramek wydania<\/li>\n<\/ul>\n<\/li>\n
                                            • Konfigurowanie i aprowizacja środowisk\n
                                                \n
                                              • Aprowizacja i konfiguracja środowisk docelowych<\/li>\n
                                              • Ćwiczenie: konfigurowanie połączeń usług<\/li>\n
                                              • Konfigurowanie automatycznych testów integracyjnych i funkcjonalnych<\/li>\n
                                              • Shift-left<\/li>\n
                                              • Konfigurowanie i uruchamianie testów dostępności<\/li>\n
                                              • Azure Load Testing<\/li>\n
                                              • Konfigurowanie i uruchamianie testów funkcjonalnych<\/li>\n<\/ul>\n<\/li>\n
                                              • Zarządzanie zadaniami i szablonami\n
                                                  \n
                                                • Grupy zadań<\/li>\n
                                                • Zmienne w potokach wydania<\/li>\n
                                                • Ćwiczenie: tworzenie grup zmiennych i zarządzanie nimi<\/li>\n<\/ul>\n<\/li>\n
                                                • Automatyzacja inspekcji kondycji\n
                                                    \n
                                                  • Automatyzacja inspekcji kondycji<\/li>\n
                                                  • Zdarzenia i powiadomienia<\/li>\n
                                                  • Elementy webhook usług<\/li>\n
                                                  • Konfigurowanie powiadomień Azure DevOps<\/li>\n
                                                  • Konfigurowanie powiadomień GitHub<\/li>\n
                                                  • Mierzenie jakości procesu wydania<\/li>\n
                                                  • Informacje o wydaniu i dokumentacja<\/li>\n
                                                  • Narzędzia do zarządzania wydaniami<\/li>\n<\/ul>\n<\/li>\n
                                                  • Wprowadzenie do wzorców wdrożeń\n
                                                      \n
                                                    • Architektura mikrousług<\/li>\n
                                                    • Klasyczne wzorce wdrożeń<\/li>\n
                                                    • Nowoczesne wzorce wdrożeń<\/li>\n<\/ul>\n<\/li>\n
                                                    • Wdrożenie blue-green i przełączniki funkcji\n
                                                        \n
                                                      • Wdrożenie blue-green<\/li>\n
                                                      • Sloty wdrożeń<\/li>\n
                                                      • Przełączniki funkcji (feature toggles)<\/li>\n
                                                      • Utrzymanie przełączników funkcji<\/li>\n<\/ul>\n<\/li>\n
                                                      • Wdrożenia canary i dark launching\n
                                                          \n
                                                        • Wdrożenia canary<\/li>\n
                                                        • Azure Traffic Manager<\/li>\n
                                                        • Dark launching<\/li>\n<\/ul>\n<\/li>\n
                                                        • Testowanie A\/B i wdrożenia progresywne\n
                                                            \n
                                                          • Testowanie A\/B<\/li>\n
                                                          • CI\/CD z pierścieniami wdrożeń (deployment rings)<\/li>\n<\/ul>\n<\/li>\n
                                                          • Integracja z systemami zarządzania tożsamością\n
                                                              \n
                                                            • Integracja GitHub z logowaniem jednokrotnym (SSO)<\/li>\n
                                                            • Projektowanie i implementacja uprawnień i ról w GitHub<\/li>\n
                                                            • Projektowanie i implementacja uprawnień i grup zabezpieczeń w Azure DevOps<\/li>\n
                                                            • Tożsamości obciążeń (workload identities)<\/li>\n
                                                            • Implementacja tożsamości zarządzanych (managed identities)<\/li>\n<\/ul>\n<\/li>\n
                                                            • Zarządzanie danymi konfiguracyjnymi aplikacji\n
                                                                \n
                                                              • Zewnętrzne wzorce przechowywania konfiguracji<\/li>\n
                                                              • Bezpieczne pliki Azure DevOps<\/li>\n
                                                              • Wprowadzenie do Azure App Configuration<\/li>\n
                                                              • Pary klucz-wartość<\/li>\n
                                                              • Zarządzanie funkcjami w Azure App Configuration<\/li>\n
                                                              • Integracja Azure Key Vault z Azure Pipelines<\/li>\n
                                                              • Zarządzanie sekretami, tokenami i certyfikatami<\/li>\n
                                                              • Pętle wewnętrzna i zewnętrzna DevOps<\/li>\n
                                                              • Włączanie dynamicznej konfiguracji i flag funkcji<\/li>\n<\/ul>\n<\/li>\n
                                                              • Infrastruktura jako kod i zarządzanie konfiguracją\n
                                                                  \n
                                                                • Wdrażanie środowisk<\/li>\n
                                                                • Konfiguracja środowisk<\/li>\n
                                                                • Konfiguracja imperatywna a deklaratywna<\/li>\n
                                                                • Konfiguracja idempotentna<\/li>\n<\/ul>\n<\/li>\n
                                                                • Tworzenie zasobów Azure za pomocą szablonów Azure Resource Manager\n
                                                                    \n
                                                                  • Zastosowanie szablonów ARM<\/li>\n
                                                                  • Składniki szablonu<\/li>\n
                                                                  • Zarządzanie zależnościami<\/li>\n
                                                                  • Modularyzacja szablonów<\/li>\n
                                                                  • Zarządzanie sekretami w szablonach<\/li>\n<\/ul>\n<\/li>\n
                                                                  • Tworzenie zasobów Azure za pomocą Azure CLI\n
                                                                      \n
                                                                    • Wprowadzenie do Azure CLI<\/li>\n
                                                                    • Instalacja Azure CLI<\/li>\n
                                                                    • Interaktywne wykonywanie poleceń Azure CLI<\/li>\n
                                                                    • Tworzenie skryptów Bash z Azure CLI<\/li>\n
                                                                    • Najlepsze praktyki pracy z Azure CLI<\/li>\n<\/ul>\n<\/li>\n
                                                                    • Azure Automation i DevOps\n
                                                                        \n
                                                                      • Tworzenie kont automatyzacji<\/li>\n
                                                                      • Elementy runbook<\/li>\n
                                                                      • Zasoby współdzielone automatyzacji<\/li>\n
                                                                      • Galeria elementów runbook<\/li>\n
                                                                      • Elementy webhook<\/li>\n
                                                                      • Integracja z kontrolą źródła<\/li>\n
                                                                      • Przepływy pracy PowerShell<\/li>\n
                                                                      • Tworzenie przepływu pracy<\/li>\n
                                                                      • Zarządzanie hybrydowe<\/li>\n
                                                                      • Punkty kontrolne i przetwarzanie równoległe<\/li>\n<\/ul>\n<\/li>\n
                                                                      • Desired State Configuration (DSC)\n
                                                                          \n
                                                                        • Dryf konfiguracji<\/li>\n
                                                                        • Desired State Configuration (DSC)<\/li>\n
                                                                        • Azure Automation State Configuration (DSC)<\/li>\n
                                                                        • Plik konfiguracji DSC<\/li>\n
                                                                        • Implementacja DSC i automatyzacja Linux na Azure<\/li>\n<\/ul>\n<\/li>\n
                                                                        • Implementacja Bicep\n
                                                                            \n
                                                                          • Wprowadzenie do Bicep<\/li>\n
                                                                          • Instalacja Bicep<\/li>\n
                                                                          • Ćwiczenie: tworzenie szablonów Bicep<\/li>\n
                                                                          • Struktura i składnia pliku Bicep<\/li>\n
                                                                          • Ćwiczenie: wdrożenie pliku Bicep z Azure Pipelines<\/li>\n
                                                                          • Ćwiczenie: wdrożenie pliku Bicep z GitHub Actions<\/li>\n
                                                                          • Wdrożenia za pomocą szablonów Azure Bicep<\/li>\n<\/ul>\n<\/li>\n
                                                                          • Wprowadzenie do bezpiecznego DevOps\n
                                                                              \n
                                                                            • Atak SQL injection<\/li>\n
                                                                            • DevSecOps<\/li>\n
                                                                            • Bezpieczny potok DevOps<\/li>\n
                                                                            • Kluczowe punkty walidacji<\/li>\n
                                                                            • Ciągła walidacja bezpieczeństwa<\/li>\n
                                                                            • Modelowanie zagrożeń<\/li>\n
                                                                            • CodeQL w GitHub<\/li>\n<\/ul>\n<\/li>\n
                                                                            • Oprogramowanie open source\n
                                                                                \n
                                                                              • Sposób budowania oprogramowania<\/li>\n
                                                                              • Oprogramowanie open source<\/li>\n
                                                                              • Kwestie korporacyjne dotyczące komponentów open source<\/li>\n
                                                                              • Licencje open source<\/li>\n
                                                                              • Typowe licencje open source<\/li>\n
                                                                              • Implikacje i oceny licencji<\/li>\n<\/ul>\n<\/li>\n
                                                                              • Analiza składu oprogramowania\n
                                                                                  \n
                                                                                • Weryfikacja bazy kodu pod kątem zgodności<\/li>\n
                                                                                • Analiza składu oprogramowania (SCA)<\/li>\n
                                                                                • Alerty Dependabot i aktualizacje zabezpieczeń GitHub<\/li>\n
                                                                                • Integracja kontroli SCA z potokami<\/li>\n
                                                                                • Narzędzia do oceny bezpieczeństwa pakietów i zgodności licencji<\/li>\n
                                                                                • Automatyczne skanowanie obrazów kontenerów<\/li>\n
                                                                                • Interpretacja alertów narzędzi skanujących<\/li>\n<\/ul>\n<\/li>\n
                                                                                • Monitorowanie bezpieczeństwa i zarządzanie\n
                                                                                    \n
                                                                                  • Bezpieczeństwo potoku<\/li>\n
                                                                                  • Microsoft Defender for Cloud<\/li>\n
                                                                                  • Scenariusze użycia Microsoft Defender for Cloud<\/li>\n
                                                                                  • Azure Policy<\/li>\n
                                                                                  • Zasady (policies)<\/li>\n
                                                                                  • Inicjatywy<\/li>\n
                                                                                  • Blokady zasobów (resource locks)<\/li>\n
                                                                                  • Microsoft Defender for Identity<\/li>\n
                                                                                  • Integracja GitHub Advanced Security z Microsoft Defender for Cloud<\/li>\n
                                                                                  • Konfigurowanie GitHub Advanced Security dla GitHub i Azure DevOps<\/li>\n<\/ul>\n<\/li>\n
                                                                                  • Zależności pakietów\n
                                                                                      \n
                                                                                    • Zarządzanie zależnościami<\/li>\n
                                                                                    • Elementy strategii zarządzania zależnościami<\/li>\n
                                                                                    • Identyfikacja zależności<\/li>\n
                                                                                    • Komponenty źródłowe i pakietowe<\/li>\n
                                                                                    • Dekompozycja systemu<\/li>\n
                                                                                    • Skanowanie bazy kodu pod kątem zależności<\/li>\n<\/ul>\n<\/li>\n
                                                                                    • Zarządzanie pakietami\n
                                                                                        \n
                                                                                      • Pakiety<\/li>\n
                                                                                      • Źródła pakietów (feeds)<\/li>\n
                                                                                      • Menedżery źródeł pakietów<\/li>\n
                                                                                      • Publiczne źródła pakietów<\/li>\n
                                                                                      • Źródła pakietów self-hosted i SaaS<\/li>\n
                                                                                      • Korzystanie z pakietów<\/li>\n
                                                                                      • Wprowadzenie do Azure Artifacts<\/li>\n
                                                                                      • Publikowanie pakietów<\/li>\n
                                                                                      • Zarządzanie pakietami za pomocą Azure Artifacts<\/li>\n<\/ul>\n<\/li>\n
                                                                                      • Migracja, konsolidacja i zabezpieczanie artefaktów\n
                                                                                          \n
                                                                                        • Identyfikacja istniejących repozytoriów artefaktów<\/li>\n
                                                                                        • Migracja i integracja repozytoriów artefaktów<\/li>\n
                                                                                        • Zabezpieczanie dostępu do źródeł pakietów<\/li>\n
                                                                                        • Role<\/li>\n
                                                                                        • Uprawnienia<\/li>\n
                                                                                        • Uwierzytelnianie<\/li>\n<\/ul>\n<\/li>\n
                                                                                        • Implementacja strategii wersjonowania\n
                                                                                            \n
                                                                                          • Wersjonowanie artefaktów<\/li>\n
                                                                                          • Wersjonowanie semantyczne<\/li>\n
                                                                                          • Widoki wydań<\/li>\n
                                                                                          • Promowanie pakietów<\/li>\n
                                                                                          • Najlepsze praktyki wersjonowania<\/li>\n<\/ul>\n<\/li>\n
                                                                                          • GitHub Packages — wprowadzenie\n
                                                                                              \n
                                                                                            • Publikowanie pakietów<\/li>\n
                                                                                            • Instalowanie pakietu<\/li>\n
                                                                                            • Usuwanie i przywracanie pakietu<\/li>\n
                                                                                            • Kontrola dostępu i widoczność pakietów<\/li>\n<\/ul>\n<\/li>\n
                                                                                            • Implementacja narzędzi do śledzenia użycia i przepływu\n
                                                                                                \n
                                                                                              • Wewnętrzna pętla (inner loop)<\/li>\n
                                                                                              • Ciągłe monitorowanie<\/li>\n
                                                                                              • Azure Monitor i Log Analytics<\/li>\n
                                                                                              • Kusto Query Language (KQL)<\/li>\n
                                                                                              • Application Insights<\/li>\n
                                                                                              • Implementacja Application Insights<\/li>\n
                                                                                              • Projektowanie i implementacja metryk i zapytań<\/li>\n
                                                                                              • Monitorowanie wydajności aplikacji za pomocą Azure Load Testing<\/li>\n<\/ul>\n<\/li>\n
                                                                                              • Tworzenie pulpitów monitorowania i statusu\n
                                                                                                  \n
                                                                                                • Konfigurowanie monitorowania w GitHub<\/li>\n
                                                                                                • Pulpity Azure Dashboards<\/li>\n
                                                                                                • Azure Monitor Workbooks<\/li>\n
                                                                                                • Power BI<\/li>\n
                                                                                                • Niestandardowe aplikacje monitorujące<\/li>\n
                                                                                                • Monitorowanie kondycji potoku: wskaźnik błędów, czas trwania, niestabilne testy<\/li>\n
                                                                                                • Optymalizacja potoków pod kątem kosztu, czasu, wydajności i niezawodności<\/li>\n
                                                                                                • Optymalizacja współbieżności potoków<\/li>\n<\/ul>\n<\/li>\n
                                                                                                • Współdzielenie wiedzy w zespołach\n
                                                                                                    \n
                                                                                                  • Współdzielenie wiedzy w zespołach deweloperskich<\/li>\n
                                                                                                  • Witryny wiki projektów Azure DevOps<\/li>\n
                                                                                                  • Integracja GitHub i Azure DevOps z Microsoft Teams<\/li>\n
                                                                                                  • Ćwiczenie: współdzielenie wiedzy zespołu za pomocą wiki projektu Azure<\/li>\n<\/ul>\n<\/li>\n
                                                                                                  • Projektowanie procesów automatyzacji analityki aplikacji\n
                                                                                                      \n
                                                                                                    • Szybkie reagowanie i rozszerzone wyszukiwanie<\/li>\n
                                                                                                    • Integracja telemetrii<\/li>\n
                                                                                                    • Narzędzia i technologie monitorowania<\/li>\n
                                                                                                    • IT Service Management Connector<\/li>\n<\/ul>\n<\/li>\n
                                                                                                    • Zarządzanie alertami i retrospektywy\n
                                                                                                        \n
                                                                                                      • Kiedy wysyłać powiadomienia<\/li>\n
                                                                                                      • Rozwiązywanie problemów z wydajnością<\/li>\n
                                                                                                      • Konfigurowanie powiadomień inteligentnego wykrywania<\/li>\n
                                                                                                      • Poprawa wydajności aplikacji<\/li>\n
                                                                                                      • Degradacja czasu odpowiedzi serwera<\/li>\n
                                                                                                      • Redukcja niepotrzebnych alertów<\/li>\n
                                                                                                      • Retrospektywy bez obwiniania (blameless retrospectives)<\/li>\n
                                                                                                      • Kultura sprawiedliwości (just culture)<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n <\/div>\n
                                                                                                        \n
                                                                                                        \n

                                                                                                        Exam<\/h2> <\/div>\n
                                                                                                        \n
                                                                                                        \n
                                                                                                          \n
                                                                                                        • \n
                                                                                                          Microsoft Practice Test Voucher<\/div>\n
                                                                                                          <\/p>\n

                                                                                                          Voucher na dostęp do oficjalnych testów przygotowujących do egzaminu Microsoft (opracowanych przez MeasureUp).<\/p>\n

                                                                                                          Voucher powinien być aktywowany na stronie marketplace.measureup.com w przeciągu 6 miesięcy od daty zakupu. Dostęp online do testów jest ważny przez 30 dni od aktywacji.<\/p>\n<\/div>\n<\/li>\n

                                                                                                        • \n
                                                                                                          Pearson \/ VUE MCP Exam Voucher<\/div>\n
                                                                                                          <\/p>\n

                                                                                                          Pearson\/VUE MCP Exam Voucher<\/strong><\/p>\n

                                                                                                          Voucher na egzamin Microsoft (jedno podejście).<\/p>\n

                                                                                                          Voucher na egzamin, do wykorzystania w centrum egzaminacyjnym Pearson VUE (w tym na egzaminach on-line), może być wykorzystany przez 1 rok od zakupu.<\/p>\n<\/div>\n<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n <\/div>\n <\/div>\n <\/div>\n <\/div>\n <\/div>\n<\/section>\n\n\n\n

                                                                                                          \n
                                                                                                          <\/div>\n<\/div>\n
                                                                                                          \n
                                                                                                          \n
                                                                                                          \n

                                                                                                          Training schedule<\/h2> <\/div>\n
                                                                                                          \n
                                                                                                          \n
                                                                                                          \n
                                                                                                          \n \n

                                                                                                          Remote<\/p>\n

                                                                                                          … if you value the opportunity to learn with a trainer and other participants, from anywhere without having to commute.<\/p>\n <\/div>\n <\/div>\n

                                                                                                          \n
                                                                                                          \n \n

                                                                                                          Stationary<\/p>\n

                                                                                                          … if you want to learn while sitting in the same room with the trainer and other participants.<\/p>\n <\/div>\n <\/div>\n

                                                                                                          \n
                                                                                                          \n \n

                                                                                                          Online<\/p>\n

                                                                                                          … if you want to learn from materials available via the interenet anywhere at any time<\/p>\n <\/div>\n <\/div>\n <\/div>\n

                                                                                                          \n
                                                                                                          \n
                                                                                                          <\/div>\n<\/div>
                                                                                                          \n
                                                                                                          \n
                                                                                                          \n
                                                                                                          \n

                                                                                                          Filters:<\/p>\n <\/div>\n

                                                                                                          \n