Containers

The IT Container concept in the Townplanner is borrowed from the C4 Model. In Archimate it would be an Application Component.

An IT Container can be one of the following types:

val nemesisDb: Database =
    ea describes Database(title = "Nemesis Database") as { it =>
      it isPartOf bcms
    }

val nemesisMs: Microservice =
    ea describes Microservice(title = "Nemesis Microservice") as { it =>
      it uses nemesisDb
      it isPartOf bcms
    }

val bcmsUi: TerminalUI =
  ea describes TerminalUI(title = "Batcave Terminal") as { it =>
    it isPartOf bcms
    it uses nemesisMs
    it isUsedBy actors.bruceWayne
  }

Properties

Description

A container can have 0 or more descriptions.

val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
      it has Description("A microservice for looking up supervillains.")
      it has Description("It was designed and built by Lucius Fox")
    }

Architecture Verdict

The architecture verdict uses the Gartner TIME model to categorize applications, determining whether to Terminate, Invest, Migrate or Tolerate them.

The architecture verdict property can appear only once on a concept. The value of the property can optionally contain a description, usually the reason why this concept was given this architecture verdict.

...
    it should BeInvestedIn()
    it should BeTolerated()
    it should BeMigrated()
    it should BeEliminated("option description: the reason why this should be eliminated")
...

Criticality

The criticality of a container describes the impact on the business if that container would fail or be unavailable. The possible values are:

The criticality property can appear only once on a concept. The value of the property can optionally contain a description, usually the reason why this concept has this criticality level.

...
    it ratesFailureAs Catastrophic("with an optional description of why it would be catastrophic")
    it ratesFailureAs Hazardous()
    it ratesFailureAs Major()
    it ratesFailureAs Minor()
    it ratesFailureAs NoEffect()
    it ratesFailureAs UnknownCriticality  
...

Resilience Measures

A resilience measure property is simply a description of what has been provided in the container to deal with failures.

A container can have 0 or more resilience measures.

...
it provides ResilienceMeasure("circuit breaker")
it provides ResilienceMeasure("fallback scenario")
...
val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
      ...
      it has Website("https://wayne.com/bcms")
      it has Wiki("https://dc.fandom.com/wiki/BCMS")
      it has ApiDocumentation("https://api.wayne.com/bcms")
      it has FunctionalDocumentations(url = "https://docs.wayne.com/bcms", title = "Functional Documentation")
      it has TechnicalDocumentation("https://reference.wayne.com/bcms")
      it has ArchitectureDocumentation(url = "https://wayne.com/architecture/bcms", title = "The BCMS in the Wayne Enterprises Town Plan")
      it has ProductionUrl("https://bcms.wayne.com")
      it has PreProductionUrl("https://staging.bcms.wayne.com")
      it has DevelopmentUrl("https://dev.bcms.wayne.com")
      it has SourceCodeRepository("https://github.com/wayne/bcms")  
      ...
}

External ID

An external ID is a reference to the description, documentation, implementation or anything else in some external system, for example in another EA tool, or in a cloud platform.

val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
      ...
      it isIdentifiedAs "{42a5e9d4-188d-4509-8145-eaac65ab86b8}" on "Sparx EA"
      ...
}

SWOT

A container can have strengths, weaknesses, opportunities and threats.

val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
      ...
      it has Strength("Lucius Fox built it")
      it has Strength("Many screens")
      it has Weakness("The screens seem to be of poor quality, possibly due to the humidity in the BatCave")
      it has Threat(
        "Throwing a chair in one of the screens seems to explode the whole system"
      )
      he has Opportunity(
        "Bringing it to the cloud might make it less vulnerable to super villains"
      )
      ...
  }

Father Time

Life events can be assigned to a container, indicating the various stages in its lifetime:

Depending on the lifecycle, a container will be visible or not in a view. System Container Views for example are time-sensitive and will not show containers that were decommissioned or are not yet in production.

val batCaveDestructionDay: Day = Day(2027, 10, 31)

val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
      ...
      it has StartedDevelopment(description =
        "Ra's al Ghul came to town"
      ) on Day(2003, 1, 1)
      it has GoneToProduction(description =
        "Just in time for the Joker"
      ) on Day(2005, 1, 1)
      it is Decommissioned(description =
        "The Batcave is destroyed"
      ) on batCaveDestructionDay
      ...
  }

Relationships

Flow

An IT Container can be both the source and the target of a flow relationship. A flow relationship can be defined on the elements on either side.

val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
    it isUsedBy actors.bruceWayne
    it uses systems.otherSystem
    it uses database
}
val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
    it isBeingUsedBy actors.bruceWayne and { that =>
      that has Description("Bruce likes to stare at this intensely")
    }
    it isUsing systems.otherSystem and { that =>
      that isImplementedBy technologyRadar.rest
      that isImplementedBy technologyRadar.tls12
    }
}

Composition

An IT Container can (and should) be part of an IT System.

val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
    it isPartOf bcms
}

Implementation

An IT Container can be implemented by 0 or more technologies. 

val go: Language = ea describes Language(title = "Go") as { it =>
  it has Description(
    "Go is a statically typed, compiled programming language designed at Google."
  )
}

val graphQL: Language = ea describes Language(title = "GraphQL") as { it =>
  it has Description(
    "GraphQL is an open-source data query and manipulation language for APIs, and a runtime for fulfilling queries with existing data."
  )
}

val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
    it isPartOf bcms
    it isImplementedBy go
    it isImplementedBy graphQL
}

Delivery

The delivery relationship indicates that an IT Container is delivered by a team, an organization or even an individual. A person or a team can be the source of a delivery relationship.

val bruceWayne: Person = ea describes Person(title = "Bruce Wayne") as { he =>
  ...
  he delivers nemesisMs
  ...
}
val bruceWayne: Person = ea describes Person(title = "Bruce Wayne") as { he =>
  ...
  he isDelivering nemesisMs and { that =>
    that has Description("Admittedly, he needed Lucius Fox")
  }
  ...
}
val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
    it isBeingDeliveredBy actors.bruceWayne and { that =>
      that has Description("Admittedly, he needed Lucius Fox")
    }
}
val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
    it isDeliveredBy actors.bruceWayne
}

Impact

An IT Container can be impacted by a decision or a project or project milestone. This relationship however is added on the side of the decision, project or milestone.

Knowledge

An IT Container can be known by a person or a team. This relationship appears in the documentation and can be very helpful when there are problems with the container.

val nemesisMs: Microservice =
  ea describes Microservice(title = "Nemesis Microservice") as { it =>
  it isKnownBy actors.diana
  it isKnownBy(target = actors.bruceWayne, level = Expert)
}