Գնահատել նախագիծը
← Բոլոր հրապարակումները

Spring Boot 3.1-ի դեպքում testcontainers-ը դեռ անհրա՞ժեշտ է

Նոր է թողարկվել Spring Boot 3.1-ը՝ իր հետ բերելով բոլորովին նոր spring-boot-docker-compose մոդուլը։ Տեսնենք՝ կարո՞ղ է այն փոխարինել testcontainers-ին մեր ինտեգրացիոն թեստերում և տեղական մշակման ժամանակ։

12 րոպե
Spring BootTestcontainersԻնտեգրացիոն թեստ

2022 թվականի նոյեմբերին թողարկված Spring Boot 3.0-ը բերեց բազմաթիվ հետաքրքիր նորույթներ, և ընդամենը մի քանի ամիս անց spring թիմը պահպանում է տեմպը՝ Spring Boot 3.1-ը նոր է թողարկվել։ Այն բերում է հսկայական թվով նոր հնարավորություններ, և այս հոդվածը կենտրոնանում է բոլորովին նոր spring-boot-docker-compose մոդուլի վրա, որը տեղական մշակման ժամանակ կարող է ավտոմատ գործարկել և կանգնեցնել docker-compose-ում սահմանված ծառայությունները։ Հենց նկատեցի այն, գլխումս հարց ծագեց. «Նշանակո՞ւմ է սա, որ կարող եմ իմ թեստային կոնտեյներները գործարկել հին լավ docker-compose.yml-ով և ամբողջովին հրաժարվել testcontainers-ից»։ Լավ… պարզաբանեմ, թե ինչ նկատի ունեմ։

Ինչու՞ է սա ինձ պետք

Մեզանից յուրաքանչյուրը գրում է կոդ, որը հենվում է արտաքին ծառայությունների վրա, ինչպիսիք են տվյալների բազաները կամ հերթերը՝ ինչ-որ տվյալներ պահելու համար։ Հավելվածի այդ արտաքին կախվածությունները docker կոնտեյներներում գործարկելը կարող է զգալիորեն պարզեցնել մշակման աշխատանքային հոսքը։ Մենք կարող ենք հավելվածը գործարկել արտաքին կախվածությունների ճիշտ նույն տարբերակների հետ, ինչ արտադրությունում, ինչը վստահություն է տալիս, որ այն ճիշտ է աշխատում։ Սակայն դրանք ձեռքով գործարկելն ու կանգնեցնելը վատ գաղափար է, հատկապես երբ պետք է ինտեգրացիոն թեստեր կատարել՝ ստուգելու համար, ասենք, արդյոք հավելվածը ճիշտ է աշխատում ընտրված տվյալների բազայի հետ։

Բարեբախտաբար, դրա համար գոյություն ունի հիանալի գրադարան՝ testcontainers, որը կարող է գործարկել և կանգնեցնել ցանկացած անհրաժեշտ կոնտեյներ և մեզ փոխարեն հոգ է տանում կոնտեյների կյանքի ցիկլի մասին։ Testcontainers-ի շնորհիվ մեր ինտեգրացիոն թեստերն աշխատում են հավելվածը կախվածությունների հետ միացրած՝ նույն տարբերակներով, ինչ արտադրությունում, և ամեն ինչ տեղի է ունենում ավտոմատ։ Եվ ոչ միայն դա. մենք կարող ենք նույնիսկ հավելվածը տեղական գործարկել և թույլ տալ, որ testcontainers-ը մեզ փոխարեն գործարկի այդ կոնտեյները։ Հիանալի զգացողություն է մեկ հրաման մուտքագրել կամ IDE-ում մեկ կոճակ սեղմել և տեսնել աշխատող հավելվածը։ Բայց հնարավո՞ր է նույնը spring-boot-docker-compose-ով։ Կարո՞ղ ենք այն օգտագործել և՛ թեստերում, և՛ տեղական մշակման ժամանակ՝ մեր սիրելի testcontainers-ը փոխարինելով զուտ spring boot-ի հնարավորություններով։ Տեսնենք։

Ինչի՞ ենք ձգտում

Այն, ինչին ուզում ենք հասնել spring-boot-docker-compose-ով, կնկարագրենք testcontainers-ի վրա կառուցված հավելվածի օգնությամբ։
Հավելվածը հենվում է MongoDB-ի վրա և այնտեղ պահում է երկու պարզ փաստաթուղթ, ինչը թույլ է տալիս առանձին կոլեկցիաների վրա կատարել երկու պարզ թեստ. այդուհանդերձ մենք ուզում ենք ընդամենը մեկ կոնտեյներ, և սա մեր նպատակներից մեկն է՝ բոլոր թեստերի համար գործարկել տվյալ կոնտեյների մեկ ինստանս՝ թեստերը արագ պահելու համար։

Ահա մեր MongoDB փաստաթղթերը

@Document
public record Article(@Id ArticleId articleId, Author author, Content content) {
}
public record ArticleId(String id) {
}
public record Author(String name) {
}
public record Content(String text) {
}
@Document
public record User(@Id String id, String name) {
}

Այս փաստաթղթերի համար պահոցներ ենք ստեղծելու spring-data-mongodb մոդուլով։

public interface UsersRepository extends MongoRepository<User, String> {
}

Վերջապես կբացահայտենք պարզ HTTP endpoint-ներ, որոնք վերադարձնում են այս պահոցների տվյալները։

@RestController
@RequestMapping("/api/users")
public class UsersController {

    private final UsersRepository usersRepository;

    public UsersController(UsersRepository usersRepository) {
        this.usersRepository = usersRepository;
    }

    @GetMapping
    public Users getAllUsers() {
        var users = usersRepository.findAll();
        return new Users(users);
    }
}

public record Users(List<User> users) {
}

Հոդվածների պահոցը և rest controller-ը գրեթե նույնական են, ուստի այստեղ դրանք բաց եմ թողնում։

Ինտեգրացիոն թեստերի կարգավորում testcontainers-ով

Հաջորդը կպատրաստենք թեստերը և testcontainers-ի կոնֆիգուրացիան, որպեսզի մեր թեստերն աշխատեն docker-ում գտնվող MongoDB-ի դեմ։

Ստորև users կոլեկցիայի համար թեստի օրինակ է։ Տվյալների բազայում պահում ենք օգտատեր և ստուգում, որ API-ն վերադարձնում է այդ օգտատիրոջը։

@Test
void shouldReturnSavedUser() {
    // given
    var user = new User(UUID.randomUUID().toString(), "username");
    usersRepository.save(user);

    // when
    Users users = testRestTemplate.getForObject("/api/users", Users.class);

    // then
    assertThat(users).isEqualTo(new Users(List.of(user)));
}

Հոդվածների համար գործնականում նույն թեստերն են։

Այժմ սահմանենք մեր կոնտեյները testcontainers-ով։

@TestConfiguration(proxyBeanMethods = false)
public class TestContainersConfiguration {

    @Bean
    @ServiceConnection
    public MongoDBContainer mongoDBContainer() {
        return new MongoDBContainer("mongo:6.0.5");
    }
}

Բոլոր ինտեգրացիոն թեստերի միջև մեկ spring կոնտեքստ կիսելու համար մենք սովորաբար պահում ենք @SpringBootTest անոտացիայով բազային դաս, որը ժառանգում են մեր թեստային դասերը. այդպես ամբողջ փաթեթը գործարկելիս ստեղծվում է միայն մեկ spring կոնտեքստ, ինչը թեստերը պահում է արագ։ Մեր կոնտեյներները նույն վերաբերմունքն են պահանջում (դրանք պետք է գործարկվեն միայն մեկ անգամ)։ Բավական է այս TestContainersConfiguration-ը ներմուծել մեր BaseIntegrationTest-ում

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Import(TestContainersConfiguration.class)
@ActiveProfiles("test")
public class BaseIntegrationTest {

Ըհը… եթե բաց եք թողել, այստեղ մենք հենվում ենք Spring Boot 3.1-ի մեկ այլ հիանալի հնարավորության վրա՝ Service Connections-ի։ Այլևս պետք չէ առանձին սահմանել մեր կոնտեյների կապի կարգավորումները (օրինակ՝ host և պորտ)։ Հենց bean-ը նշվում է @ServiceConnection-ով, նրա կապի կարգավորումները ավտոմատ վերցվում են աշխատող կոնտեյներից։

Սա ամբողջ անհրաժեշտ կոնֆիգուրացիան է։ Երբ հիմա գործարկում ենք թեստերը, testcontainers-ը բարձրացնում է թարմ MongoDB կոնտեյներ, և մեր հավելվածն օգտագործում է այն թեստերի ընթացքում։

Container mongo:6.0.5 is starting: 89bd7f517e0eacedae7af96c04cdcf8c8a5878cc8fcec3e57560d1c9b054914c
Container mongo:6.0.5 started in PT1.040507S

Testcontainers-ի օգտագործումը մշակման ժամանակ

Երբ մեր թեստերն արդեն աշխատում են ավտոմատ գործարկված MongoDB-ի դեմ, հավելվածը կկարգավորենք տեղական միջավայրում այնպես, որ testcontainers-ը MongoDB-ն այնտեղ նույնպես գործարկի մեզ համար, ինչը մեզ տանում է հաջորդ նպատակին՝ թեստերը և հավելվածը տեղական միջավայրում գործարկելու համար օգտագործել կոնտեյների մեկ և նույն կոնֆիգուրացիան։

Դրա համար մեզ պետք է նոր main հավելված մեր թեստային կոդի ներսում, որպեսզի այն հասանելիություն ունենա թեստային classpath-ին (testcontainers և կոնտեյների կոնֆիգուրացիա)։

public class TestApplication {

    public static void main(String[] args) {
        SpringApplication.from(Application::main)
                .with(TestContainersConfiguration.class)
                .run(args);
    }
}

Այստեղ SpringApplication-ը գործարկում ենք մեր հիմնական Application-ից բեռնված ամբողջ կոնֆիգուրացիայով, և դրան գումարած ավելացնում ենք MongoDB testcontainers կոնֆիգուրացիան և պարզ դաս, որը տեղական միջավայրում մեկնարկի ժամանակ օրինակային տվյալներ է դնում մեր տվյալների բազայում։

Մենք նաև ուզում ենք տեղական միջավայրում տվյալների բազան լցնել օրինակային տվյալներով՝ ցույց տալու համար, որ տեղական և թեստային տվյալները չեն ազդում միմյանց վրա։ Դրա համար կօգտագործենք spring profiles և spring conditional auto-configuration, որպեսզի տվյալների սկզբնավորումը միանա միայն տեղականորեն։ Այստեղ ունենք երկու հատուկ պրոֆիլ՝ local և test։ Ահա թե ինչպիսին է մեր տվյալների սկզբնավորիչը։

@Configuration
public class InitialDataForDevelopment {

    @Bean
    @ConditionalOnProperty(name = "data.initialize", havingValue = "true")
    public CommandLineRunner commandLineRunner(UsersRepository usersRepository) {
        return args -> usersRepository.save(new User(UUID.randomUUID().toString(), "name"));
    }
}

Ինչպես տեսնում եք, օրինակային տվյալները սկզբնավորվում են միայն data.initialize=true հատկության դեպքում, և spring profiles-ի շնորհիվ կարող ենք data.initialize=true սահմանել միայն local պրոֆիլում, այնպես որ մեր թեստերը մեկնարկում են առանց որևէ տվյալի։ Դա տանում է հաջորդ կարևոր նպատակին. եթե նախ գործարկենք հիմնական հավելվածը, այն մեր բազան կլցնի որոշ տվյալներով, և մինչ այն դեռ աշխատում է, մենք ուզում ենք թեստերը գործարկել այնպես, որ դրանք այդ տվյալները չտեսնեն. մի խոսքով՝ ուզում ենք, որ տեղական միջավայրում աշխատող կոնտեյները և թեստերը մեկուսացված լինեն միմյանցից։ Testcontainers-ը դա տալիս է լռելյայն։ Երբ հավելվածը գործարկում եմ տեղականորեն, այն մեկ կոնտեյներ է գործարկում։

Creating container for image: mongo:6.0.5
Container mongo:6.0.5 is starting: cd242f72eb33b89542aeb8710c0a0b9fed12cd4fb0feffb5fa443e2b0199f3e7

Հետո, երբ հավելվածս աշխատում է և սկզբնական տվյալները տեղում են, գործարկում եմ թեստերը, և տեսնում ենք, որ testcontainers-ը դրանց համար գործարկել է առանձին MongoDB կոնտեյներ։

Container mongo:6.0.5 is starting: 40aa3198e15416f98e029f43b0a7846d17161ad707dfd5ffde6246f6861302bd

Այսպիսով, իմ մեքենայի վրա այժմ աշխատում է երկու կոնտեյներ, և իմ թեստերը չեն խանգարում տեղական մշակման միջավայրին։

 ~/Workspace/demo-spring-boot-testing> docker ps | grep mongo

40aa3198e154   mongo:6.0.5                 "docker-entrypoint.s…"   49 seconds ago   Up 48 seconds   0.0.0.0:58327->27017/tcp   quirky_hawking
cd242f72eb33   mongo:6.0.5                 "docker-entrypoint.s…"   29 minutes ago   Up 29 minutes   0.0.0.0:57885->27017/tcp   cool_jennings

Բավականին հիանալի է, չէ՞։

Կա ևս մեկ կարևոր նպատակ, որը վերը բերված օրինակները չցուցադրեցին՝ գործարկել ցանկացած անհրաժեշտ կոնտեյներ։ Մեր պարզ օրինակը գործարկում է միայն MongoDB տվյալների բազա, բայց ավելի բարդ միջավայրերը պահանջում են շատ ավելի շատ ծառայություններ, ինչպիսիք են Kafka-ն, Mockserver-ը կամ Neo4j-ն, և testcontainers-ը աջակցում է դրանք բոլորը։

Ամփոփելով՝ մեր նպատակներն են.

  1. Կարողանալ կոնտեյներներ գործարկել տեղական մշակման համար
  2. Կարողանալ կոնտեյներներ գործարկել թեստերի համար (տվյալ կոնտեյների միայն մեկ ինստանսով)
  3. Թեստերի և տեղական մշակման կոնտեյները պահել մեկուսացված
  4. Կարողանալ գործարկել ցանկացած կոնտեյներ, որ ուզում ենք

Նոր spring-boot-docker-compose մոդուլը գործնականում

Տեսնենք՝ կարո՞ղ ենք հասնել մեր առաջին նպատակին՝ կարողանալ կոնտեյներներ գործարկել տեղական մշակման համար։

Մոդուլը հենց դրա համար է ստեղծվել, ուստի պետք է բավականին պարզ լինի։ Նախ spring-boot-docker-compose-ը ավելացնում ենք մեր կախվածություններին. մենք օգտագործում ենք maven, ուստի սա մտնում է մեր pom.xml ֆայլը։

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-docker-compose</artifactId>
</dependency>

Հետո մեր արտաքին կախվածությունները նկարագրում ենք docker-compose.yml ֆայլում։

version: '3.9'
services:
  mongodb:
    restart: always
    image: mongo:6.0.5
    ports:
      - 27017:27017
    tmpfs:
      - /data/db

Պատրաստ է։ Երբ հիմա գործարկում ենք հավելվածը, spring boot-ը նկատում է docker-compose.yml ֆայլը և գործարկում այն մեզ համար։ Առաջին նպատակին հասանք։

.s.b.d.c.l.DockerComposeLifecycleManager : Found Docker Compose file 'MY_HOME_DIRECTORY_PATH/demo-spring-boot-testing/docker-compose/docker-compose.yml'
o.s.boot.docker.compose.core.DockerCli   : Network docker-compose_default  Creating
o.s.boot.docker.compose.core.DockerCli   : Network docker-compose_default  Created
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Creating
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Created
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Starting
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Started
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Waiting
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Healthy

Բավականին հեշտ էր, չէ՞։ Անկեղծ ասած՝ մեկ կարգավորում պետք եղավ փոխել, քանի որ իմ նախագիծը բազմամոդուլ է, և spring boot-ին պետք էր ասել, թե որտեղ է գտնվում իմ docker-compose.yml ֆայլը, բայց դա ընդամենը մեկ պարզ գրառում է մեր application.properties-ում։ Պատճառն այն է, որ այն կոնֆիգուրացիոն ֆայլը փնտրում է ընթացիկ աշխատանքային թղթապանակում, իսկ բազմամոդուլ նախագծում աշխատանքային թղթապանակը տարբերվում է՝ կախված նրանից՝ թեստերը կամ main դասը գործարկում եմ IDE-ից. դրա համար այն սահմանեցի ձեռքով, և բնականաբար ./mnvw test-ի նման հրամաններն էլ աշխատում են։ Մեկ մոդուլով նախագծում, սակայն, պարզապես docker-compose.yml ֆայլը գցում եք նախագծի արմատային թղթապանակ, և ամեն ինչ պատրաստ է։

spring.docker.compose.file=./docker-compose/docker-compose.yml

Անցնենք հաջորդ նպատակին՝ կարողանալ կոնտեյներներ գործարկել թեստերի համար (բոլոր թեստերի համար տվյալ կոնտեյների միայն մեկ ինստանսով)

Իմ առաջին ենթադրությունն այն էր, որ լրացուցիչ աշխատանք պետք չի լինի, և այն պարզապես կաշխատի (չէ՞ որ docker-compose.yml ֆայլն արդեն կա)։ Սակայն պարզվում է, որ լռելյայն spring boot-ը թեստերի ժամանակ չի գործարկում docker-compose.yml-ում սահմանված կոնտեյները. այդ քայլը պարզապես բաց է թողնվում։ Այդ վարքը, սակայն, վերահսկում է մի դրոշակ, ուստի փոխենք այն։

spring.docker.compose.skip.in-tests=false

Կոնֆիգուրացիայի այս փոքրիկ մասով մեր թեստերը կարող են օգտագործել docker compose-ի MongoDB կոնտեյները։ Ստորև թեստի գործարկման լոգեր են, որոնք ցույց են տալիս կոնտեյների մեկնարկը։ Բնականաբար, բոլոր թեստերն անցան, և կոնտեյները ամբողջ փաթեթի համար գործարկվեց միայն մեկ անգամ։

.s.b.d.c.l.DockerComposeLifecycleManager : Found Docker Compose file 'MY_HOME_DIRECTORY_PATH/Workspace/demo-spring-boot-testing/docker-compose/docker-compose.yml'
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Created
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Starting
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Started
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Waiting
o.s.boot.docker.compose.core.DockerCli   : Container docker-compose-mongodb-1  Healthy

Երկրորդ նպատակը կարելի է նշել որպես կատարված։

Երրորդ նպատակ՝ թեստերի և տեղական մշակման կոնտեյները պահել մեկուսացված

Այստեղ հանդիպեցի առաջին թերությանը։ Ցավոք, այդքան հեշտ չէ կարգավորել այնպես, որ տեղական միջավայրի կոնտեյները աշխատեն թեստերում օգտագործվողներից առանձին։ Պատճառն այն է, որ նոր մոդուլը որոշում է՝ նոր կոնտեյներներ գործարկել թե ոչ, պարզապես docker compose ps հրամանի վերադարձրածը պարզ ստուգելով։ Եթե որևէ ծառայություն արդեն բարձր է, նոր կոնտեյներներ չեն ստեղծվում, և մեր թեստերը միանում են տեղական մշակման համար գործարկված կոնտեյներին։ Ինչպես է սա աշխատում ներսից, կարող եք տեսնել այստեղ և այստեղ։ Արդյունքում այս կոնտեյները տարբեր տվյալների բազաներով, docker ցանցերով կամ նույնիսկ docker compose պրոֆիլներով գործարկելու փորձերը ձախողվում են։

Միակ լուծումը, որ գտա, յուրաքանչյուր միջավայրի համար (այստեղ՝ local և test) առանձին docker-compose.yml ֆայլ է՝ տեղադրված իր սեփական թղթապանակում։ Նույն կոնֆիգուրացիայով մի քանի docker-compose.yml ֆայլ պահելը լավ չէ, բայց բարեբախտաբար docker compose-ն առաջարկում է Extensions։ Կրկնությունից խուսափելու համար ծառայության գրեթե ամբողջ կոնֆիգուրացիան կարող ենք դնել մեկ ընդհանուր docker-compose.yml-ում, ապա այդ ընդհանուր սահմանումը վերօգտագործել docker-compose-local.yml-ում և docker-compose-test.yml-ում փոքր ճշգրտումներով. MongoDB-ի դեպքում պետք է բացահայտենք տարբեր պորտեր, որպեսզի երկու կոնտեյներ կարողանան աշխատել կողք կողքի։ Սրանք իմ նոր docker-compose ֆայլերն են։

./docker/docker-compose-common.yml

version: '3.9'
services:
  mongodb:
    restart: always
    image: mongo:6.0.5
    tmpfs:
      - /data/db

./docker/local/docker-compose-local.yml

version: '3.9'
services:
  mongodb-local:
    extends:
      file: ../docker-compose-common.yml
      service: mongodb
    ports:
      - 27017:27017

./docker/test/docker-compose-test.yml

version: '3.9'
services:
  mongodb-test:
    extends:
      file: ../docker-compose-common.yml
      service: mongodb
    ports:
      - 27018:27017

Գիտակցում եմ, որ սա կատարյալ չէ և պահանջեց docker compose-ի հետ մի փոքր ման գալ, բայց ամեն ինչ հաշվի առնելով՝ կասեի, որ այս նպատակը կատարված է։

Վերջին, բայց ոչ պակաս կարևոր՝ կարողանալ գործարկել ցանկացած կոնտեյներ, որ ուզում ենք

Այստեղ հանդիպում ենք երկրորդ, թեև շատ ավելի փոքր խնդրի։ Այս պահին մենք չենք կարող արկղից դուրս գործարկել ցանկացած կոնտեյներ. աջակցվում են միայն մի քանիսը (որոնք, հավանաբար, բավարար կլինեն օգտագործման դեպքերի մեծ մասի համար)։ Օրինակ՝ MongoDB, Redis, PostgreSQL, Cassandra կամ Elasticsearch աշխատում են առանց լրացուցիչ կոդի, բայց եթե ձեզ պետք է մի բան, որը մոդուլը դեռ չի ծածկում, ինչպես Kafka-ն կամ Neo4j-ն, պետք է գրեք ձեր սեփական DockerComposeConnectionDetailsFactory իրականացումը, որը ձեզ համար կկառուցի ConnectionDetails։ Սա ևս մեկ կոդի կտոր է պահպանելու համար, ուստի իդեալական չէ։ Այդուհանդերձ, ամենայն հավանականությամբ, ժամանակի հարց է, մինչև spring-boot-docker-compose-ը ձեռք բերի ավելի շատ DockerComposeConnectionDetailsFactory իրականացումներ։

Եզրակացություն

Ինչպես տեսանք, նոր spring-boot-docker-compose մոդուլը բավականին հզոր է և պարզ օգտագործման համար։ Կոնտեյների մեկուսացումը կարող է որոշ չափով բարդ կարգավորվել, և այն ստիպում է մեր ‘docker-compose.yml’ ֆայլերում որոշ կրկնություն անել, բայց այն կարող է անել ամեն ինչ, ինչ մենք արել ենք testcontainers-ով։ Այն նաև արկղից դուրս աջակցում է ավելի քիչ կոնտեյներ, քան testcontainers-ը (ինչը շատ դեպքերում կարևոր չէ, և վստահ եմ՝ ավելիները կհայտնվեն հետագա թողարկումներում)։ Թվում է՝ մեծ նոր խաղացող է եկել և պատրաստվում է ցնցել ստատուս քվոն։

Ընդհանուր առմամբ, վախենում եմ՝ չեմ կարող ասել, թե արդյոք պետք է testcontainers-ի փոխարեն անցնեք spring-boot-docker-compose-ին։ Դա ընտրություն է, որ դուք պետք է կատարեք ինքներդ։ Հավատում եմ, որ այս հոդվածը ծածկել է այն սցենարների մեծ մասը, որոնցում ձեր մշակման աշխատանքային հոսքում docker կոնտեյներներ կուզենաք, բայց հիշեք, որ մոդուլը բավականին նոր է և զուրկ է testcontainers-ի առաջարկած որոշ հնարավորություններից, ինչպես, օրինակ, կոնտեյներների զուգահեռ գործարկումը կամ կոնտեյներների վերօգտագործումը, հիշատակելու համար ընդամենը երկուսը։