Integration With GitLab

JFrog Platform Administration Documentation

Content Type: Administration / Platform

Platform Administration
Project Administration
Projects
Project Benefits
Get Started with Projects
View Projects in the JFrog Platform
Projects Concepts and Terminology
Basic Projects Terminology
Xray Terminology and Concepts in Projects
Project Roles and Members Concepts
Global and Project Role Types
Project-Supported Actions by Role Types
Administer the Platform Role (Platform Admin)
Global Roles for Projects
Project Admin Role
Project Roles
Onboard Projects in an Upgraded Environment
Create a Project
Step 1: Set Up a New Project
Step 2: Assign Members to a Project
Step 3: Add or Assign Resources to Projects
Repository Resources for Projects
Build Resources for Projects
Project Build-Info
Pipelines Resources for Projects
Add Pipeline Integrations to a Project
Add Pipeline Data Sources to a Project
Add Pipeline Node Pools
Dedicated Project REST APIs
Manage Projects
View Projects in a Dashboard View
Modify a Project
Manage Storage Quotas
Editing the Project Settings
Assign Multiple Projects to Resources
Share Repositories Across Multiple Projects
Change Repository Ownership from Project to Project
Unassign Repository from a Project
Unshare Repositories Across Projects
Remove a Project Member
Remove a Project Group
Delete a Project
Manage Project Roles and Members
Manage Global Roles
Set Environments and Actions for Global Roles
Create Custom Global Roles
Custom Global Roles
Update a Global or Project Role
Manage Project Roles
Step 1: Create Project Roles
Step 2: Add Members to Projects
Project Management Task Quick Guide
Project Creation Tasks
Project Management Tasks
Project User Management Tasks
Environments
Create a Custom Global Environment
Create a Custom Project Environment
Assign Environments to Global and Project Roles
Assign Environments to Repositories
Delete a Custom Environment
Identity and Access
Security Configuration
Allow Anonymous Access
Hide Existence of Unauthorized Resources
Password Encryption Policy
Passwords Encryption
Disable Basic Authentication Method
Hide Basic Authentication
Enable Token Generation via API
Multi-factor Authentication
View the Join Key
Password Expiration Policy
User Lock and Login Suspension
Manage API Keys
Token Expiration
Hide SSO Providers
Manage Users
User Types
Administrator Users
The Anonymous User
Important Information on Anonymous Users
Create or Edit Users
Add New Users with Invite (Trial Users only)
Recreate the Default Admin User
Disable Remember Me at Login
Manage Groups
Create and Edit Groups
Assign Users to Groups
Set Groups for a User
Set Users for a Group
Automatically Assign Users to a Group
Assign Admin Privileges to a Group
Permissions
Create and Manage Permissions
Select Resources
Add Repositories
Add Builds
Add Release Bundles
Add Destinations
Add Pipeline Sources
Select Users and Assign Permission Actions
Permission Details
Select Groups and Assign Permission Actions
Permission Details
JFrog Platform Permission Migration
Legacy Permissions
User Profile
View the Profile
Unlock Your Profile
Secure Your Password
Add SSH Key
Bind OAuth Accounts
Change Your Personal Settings
Understanding Identity Tokens
Comparing Identity Reference Tokens With API Keys
Generate Identity Token
Change Your Email and Password
Password Reminder
API Key
JFrog API Key Deprecation Process
JFrog API Key Deprecation for Cloud Customers
API Key User Collection for Cloud Customers
JFrog API Key Deprecation for Self-Hosted Customers
API Key User Collection for Self-Hosted Customers
API Key Deprecation Configuration Create and Usage Flags
Block Creation of New API Keys
Work with API Keys (Until Deprecated)
API Keys REST API
Centrally Secure Passwords
Access Tokens
Access Token Creation by Project Admins
Token Certificates
Resetting Token Certificates
Certificates in HA - Key Pair Propagation in an Existing HA Cluster
Basic Authentication
Authorization Headers
Generate Expirable Tokens
Use the Revocable and Persistency Thresholds
Revocable Expiry Threshold
Special Cases
Set the Revocable Expiry Threshold
Persistency Threshold
Set the Persistency Threshold
Relationship Between the Two Thresholds
Generate Refreshable Tokens
Generate Admin Tokens
Generate Scoped Tokens
View the Scope of a Token
Create an Admin Scoped Token
Create an Admin Scoped Reference Token
Create a Project Admin Token
Create a User Scoped Token
Create a Group Scoped Token
Generate Pairing Tokens
How do Pairing Tokens and Join Keys Differ?
Master Token
Supported Pairing Tokens
Pairing Tokens to Bind a JPD and a Mission Control Microservice
Pairing Tokens to Set up Cold Storage (Using the API)
View and Revoke Tokens
Support Authentication for Non-existing Users
Binding Tokens
How do Binding Tokens Differ from a Circle of Trust?
Set Up Binding Tokens for Federated Repositories
Remove Bindings
Circle of Trust (Cross-Instance Authentication)
Why do I Need a Circle of Trust?
How to Establish a Circle of Trust
Security Restrictions
Access Token REST API
Security Keys Management
Manage Signing Keys
Manage RSA and GPG Key Pairs
Add RSA Keys Pairs
Generate RSA Keys
Upload RSA Keys
Configure Alpine Repositories with RSA Keys
Add GPG Key Pairs
Generate GPG Keys
Upload GPG Keys
Manage Vault RSA and GPG Key Pairs
Set up a New RSA/GPG Key in Vault
Change an Uploaded Key with a Vault Key
REST API Commands to Manage Keys
Manage WebStart and Jar Signing
Generate JAR Signing Keys
Set Your Keystore and JAR Signing Keys
Remove a JAR Signing Key Pair
Configure Virtual Repositories to Sign JARs
Manage Public Keys
Add a Public Key
Manage SSH Keys
Configure SSH Server Authentication
Configure User Authentication with your Public Key
Configure the GIT LFS or CLI Client
Include Pattern System Properties for SSH Configuration
Exclude Pattern System Properties for SSH Configuration
Supported Values By Algorithm Type for SSH Configuration
Vault
How Does Vault Work?
Set up HashiCorp Vault Connectors
Connect HashiCorp Vault to the JFrog Platform Using REST API
Retrieve Signing Keys from HashiCorp Vault
REST API Support for Vault
Logging in using Multi-factor Authentication
MFA Enrollment - First Time Login with MFA Enabled
Log in with Multi-factor Authentication
Key Encryption
Activate and Deactivate Password Encryption
Export and Import the Artifactory Encryption Key
Authentication Providers
SCIM
Implemented SCIM Endpoints
Generate a Scoped Token for SCIM
Provisioning with Okta
Provisioning with Azure AD
LDAP
LDAP Configuration
LDAP Groups
LDAP Groups Usage
Manage Permissions for LDAP Groups
LDAP Group Synchronization Strategies
Synchronize LDAP Groups with the JPD Through the UI
Synchronize LDAP Groups with the JPD Using the REST API
Customize the LDAP Timeout / LDAP Referral Strategy
Enforce Dynamic Search of Attributes for LDAP Groups
Non-UI Authentication Cache for LDAP
Avoid Clear Text Passwords
Prevent Authentication Fallback to the Local Artifactory Realm
Using LDAPS (Secure LDAP)
Entra ID
Configure Entra ID
Import Entra ID Groups
Support for Nested Entra ID Groups
Using Secure Entra ID
SAML SSO
SAML SSO Configuration
SAML-Based SSO Login Process
SAML SSO Configuration with Azure
SAML SSO Configuration with Google
SAML SSO Configuration with Okta
SAML SSO Configuration With Keycloak
SAML-Based SSO Logout Process
SAML Profiles and Bindings
SAML Login Failure
Using API Key with SAML Users
Enabling Synchronization of LDAP Groups for SAML SSO
OAuth SSO
OAuth SSO Usage
Configure OAuth
Add a New OAuth Provider
Use Query Params for OAuth
Enable Authorization Code Flow with PKCE
Enable and Disable Personal OAuth SSO
Binding Existing User Accounts
Create OAuth Provider Accounts
GitHub OAuth Setup
Google OAuth Provider Setup
Cloud Foundry UAA OAuth Setup
Use Secure OAuth
Use API Key with OAuth Users
Use OAuth on High Availability Setup
OpenID Connect Integration
OpenID Connect Integration Benefits
OpenID Connect Configurations Overview
Understanding the OIDC Token
Identity Mappings
JSON Claims
Multiple Values in JSON Claims
Wildcard Values in JSON Claims
Dynamic Mapping
JFrog CLI Code Snippets
Configure an OIDC Integration
Configure Identity Mappings
View OIDC Configurations
View OIDC Configuration Identity Mappings
Integration with Azure
Integration of JFrog OIDC with Azure
Integration with GitHub Actions
GitHub Actions OIDC Integration Workflow
Configure JFrog Platform OIDC Integration with GitHub Actions
Setting up GitHub Actions to Establish Trust with the JFrog Platform
Configure OIDC-GitHub Integration with Code Snippets
Configuring Permissions in the Workflow YAML
Sample Integration of JFrog OIDC with GitHub Actions
Sample GitHub Actions Workflow YAML
Additional Sample Workflow YAML
Integration With GitLab
Configure JFrog OIDC Integration with GitLab
Sample GitLab Workflow YAML
HTTP SSO
Configure HTTP SSO in JPD
Integrate Apache and Tomcat for HTTP SSO
Set Up a Reverse SSL Proxy for SSO
Modify Webserver Configuration File to Set Reverse SSL Proxy for SSO
Use API Key with HTTP-SSO Users
Atlassian Crowd and JIRA Integration
Configure Crowd Integration
Crowd Groups
General Management
General System Settings
General Settings
Direct Cloud Storage Download Settings
Look and Feel Settings (Branding)
Custom Message
Custom Login Dialog
Mail Server Configuration
Create Webhooks in the JFrog Platform
Manage Licenses
License Management
Dynamic License Expiration
Manage License Buckets
Obtain a License Bucket
Add a License Bucket
View License Bucket Information
Split a License Bucket
Attach Licenses from a License Bucket to a JPD
Remove a License Bucket
Update Licenses in a License Bucket
Automate License Buckets Using JFrog CLI
Deploy and Release Licenses in a License Bucket with JFrog CLI
License Management for an Individual Artifactory or Artifactory Edge
Manage Proxy Servers
Define Proxy Server
Configure an NTLM Proxy
Set Exclusions to the Default Proxy
Webhooks
Predefined Webhooks
Custom Webhooks
Custom Webhooks Payload Templates
Custom Webhooks Examples
View Webhooks for all Projects
View Webhooks for a Project
Test a Webhook
Webhooks Troubleshooting
View Webhooks Troubleshooting Data in the UI
Webhooks Troubleshooting Data Format
Configure Webhooks Troubleshooting in Self-Hosted JFrog Platform
Event Types
Domain: Artifact
Domain: Artifact Properties
Domain: Docker
Domain: Build
Domain: Release Bundle
Domain: Curation
Domain: Distribution
Domain: Destination
Domain: User
Domain: Release Bundle v2
Domain: Release Bundle v2 Promotion
Webhooks REST API Support
Trigger a GitHub Action using Custom Webhook
Monitoring and Logging
Monitoring Storage
Monitor Binaries
Monitor the File Store
Monitor Repositories
Monitoring Service Statuses
View the Service Statuses
Monitor Artifactory Microservices
Monitor Xray Microservices
Monitor Distribution Microservices
Monitoring Replication
Managing Disk Space Usage
Regular Maintenance Operations
Log Files Location and Naming
Archived Logs
Log File Structure
Service Log
Request Log
Outbound Request Log
Router Request Log
Console Log
View Log Files from the UI
Send Logs to Syslog
Configure the logback library
Configure syslog on your machine
Configure Log Verbosity with Logback for Java-based Microservices
Configure Log Verbosity with System YAML for Non-Java Microservices
Access Log
Audit Trail Log
Log Analytics
New Relic
New Relic Setup
New Relic Environment Configuration
Fluentd Installation for New Relic
Fluentd Configuration for New Relic
Dashboards with New Relic
Splunk
Prometheus with Grafana
Datadog
Datadog Integration Installation and Setup
Datadog Integration Dashboards
Sumo Logic
Configure Log Analytics for Sumo Logic
Cloud Log Collection
Live Logs
Open Metrics
Artifactory Metrics
Artifactory Service Metrics
Release Lifecycle Management Metrics
Router Metrics
Access Metrics
Topology Metrics
Event Metrics
JFConnect Metrics
Observability Service Metrics
Federated Repository Metrics
Mission Control Metrics
Workers Metrics
Xray Metrics
Pipelines Metrics
Usage Example - Prometheus
Artifactory JMX MBeans
JMX MBeans Repositories
JMX MBeans Federated Repositories
JMX MBeans Executor Pools
JMX MBeans Storage
JMX MBeans HTTP Connection Pools
JMX MBeans Events
JMX MBeans Logging
Configuring Log Rotation for Tomcat
Topology
Manage Platform Deployments
Register a Platform Deployment
View Platform Deployment Information
Delete Platform Deployments
View JPD Health and Services
View Access Federation Status
Check Data Replication Status
Access Federation
Enable Mission Control for Access Federation
Establish the Circle of Trust
Configure Access Federation Topologies
Set up the Relationship in Access Federation
Mesh Topology
Star Topology
Configure Synchronization in Access Federation
Access Federation Parameters
Handle Synchronization Conflicts in Access Federation
Conflict Resolution in Access Federation
Synchronize Data in Access Federation
Invoke a Full Broadcast from the Access Federation Menu
Apply a REST API Endpoint on the Source Service to Invoke a Full Broadcast
Step 1: Obtain Service IDs
Step 2: Inbound Configuration
Step 3: Outbound Configuration
Step 4: Invoke Synchronization in Access Federation
Revive a Stale Service
Remove a Registered Synchronization Target
Access Federation REST API
API Keys and Access Federation
Workers
Workers Features
Workers Benefits
View Workers for All Projects
View Workers for a Project
Workers Limitations
Workers Vs Webhooks
Workers Vs User Plugins
Get Started with Workers
TypeScript Code for Workers
TypeScript APIs
PlatformContext
PlatformClients
PlatformHttpClient
IPlatformHttpResponse
PlatformHttpClientError
Configure Workers
Supported Worker Events
Configure Workers in the UI
Configure Event Driven Workers
Configure Event Driven Workers for Artifactory
Artifactory Workers Code Samples
After Build Info Save Worker Code Sample
After Copy Worker Code Sample
After Create Property Worker Code Sample
After Create Worker Code Sample
After Delete Property Worker Code Sample
After Delete Worker Code Sample
After Download Worker Code Sample
After Move Worker Code Sample
After Remote Download Worker Code Sample
Alt Remote Path Worker Code Sample
Alt All Responses Worker Code Sample
Alt Remote Content Worker Code Sample
After Download Error Worker Code Sample
Before Copy Worker Code Sample
Before Create Property Worker Code Sample
Before Create Worker Code Sample
Before Delete Property Worker Code Sample
Before Delete Replication Worker Code Sample
Before Delete Worker Code Sample
Before Directory Replication Worker Code Sample
Before Download Worker Code Sample
Before File Replication Worker Code Sample
Before Move Worker Code Sample
Before Property Replication Worker Code Sample
Before Build Info Save Worker Code Sample
Before Download Request Worker Code Sample
Before Remote Download Worker Code Sample
Before Remote Info Worker Code Sample
Before Statistics Replication Worker Code Sample
Before Upload Worker Code Sample
Configure Event Driven Workers for Access
Access Workers Code Samples
Before Create Token Worker Code Sample
Before Revoke Token Worker Code Sample
Before Token Expiry Worker Code Sample
Configure Scheduled Worker
Scheduled Worker Code Sample
Configure Http-Triggered Worker
Http-Trigged Worker Code Sample
Trigger Http-Triggered Worker From a Webhook
Configure Workers via API
Configure Workers via CLI
Configure Terraform to Create and Manage Workers
Step 1: Configure JFrog Credential for Terraform Provider
Step 2: Create Terraform Plan
Step 3: Initialize and Preview the Terraform Plan
Step 4: Apply Terraform Plan
Step 5: Verify Worker
Workers Code Samples
Manage Configured Workers
View Configured Workers
Search Configured Workers
Enable/Disable Configured Workers
Edit Configured Workers
Delete Configured Workers
Workers Troubleshooting
View Workers Run History
Workers Troubleshooting Log Sample Code
Retention Policies
Cleanup Policies
Cleanup Features
Cleanup Limitations
Cleanup Known Issues
Cleanup Use Cases
Cleanup Supported Packages
Getting Started with Cleanup
Cleanup - User Activities and Authorizations
Grant Permission to a Project Admin
Work with Cleanup
Create Cleanup Policy
Create Cleanup Policy - Package
Create Cleanup Policy - Release Bundle V2
What Happens after the Cleanup Policy is Created?
Manage Cleanup - Policies
View All Cleanup Policies
Search Cleanup Policy
Perform Dry Run Cleanup Policy
Enable/Disable Cleanup Policy
Disable All Cleanup Policies
Run Cleanup Policy Manually
Download Last Run Report Cleanup Policy
Stop a Running Cleanup Policy
Stop All Cleanup Policy Runs
Edit Cleanup Policy
Delete Cleanup Policy
Manage Cleanup - Runs
View All Cleanup Runs
Stop All Cleanup Policy Runs
Download and Review Cleanup Run Report
Cleanup Run Report Overview
Cleanup Policies System Properties
Archive
Smart Archiving
Smart Archiving Features
Smart Archiving Limitations
Smart Archiving Known Issues
Smart Archiving Use Cases
Smart Archiving Architecture
Smart Archiving Supported Packages
Get Started with Smart Archiving
Configure Smart Archiving Instance
Smart Archiving - User Activities and Authorizations
Grant Permission to Project Admin
Work with Smart Archiving and Restore
Create Smart Archiving Policy
What Happens After the Smart Archiving Policy is Created?
Manage Smart Archiving - Policies
View All Smart Archiving Policies
Search Smart Archiving Policy
Perform Dry Run on Smart Archiving Policy
Enable/Disable Smart Archiving Policy
Disable All Smart Archiving Policies
Run Smart Archiving Policy Manually
Download Smart Archiving Policy Last Run Report
Stop Running Smart Archiving Policy
Stop All Smart Archiving Policy Runs
Edit Smart Archiving Policy
Delete Smart Archiving Policy
Manage Smart Archiving - Runs
View All Smart Archiving Runs
Stop All Smart Archiving Policy Runs
Download and Review Smart Archiving Run Report
Smart Archiving Run Report Overview
Search and Restore Archived Packages
Search Archived Packages
Restore Archived Packages
Manage Restore Runs
View All Restore Runs
Download and Review Restore Run Report
Restore Run Report Overview
Monitor Smart Archiving and Restore
Monitor Smart Archiving Storage Info
Monitor Smart Archiving and Restore - via UI and Logs
Cold Storage
Introduction to Cold Storage
Cold Storage Architecture
Cold Storage Features
Monitor Cold Storage
Manage Cold Storage Bindings
Optimize Cold Storage Performance
Working with Cold Storage
Set Up Archive Retention Policies
Create an Artifact Retention Policy
Supported Package Types for Package Retention Policies
Create a Package Retention Policy
What Happens after the Archive Policy is Created?
Manage Archiving Policies
Search and Restore Archived Artifacts or Packages
Search for Archived Artifacts
Search for Archived Packages
Restore Archived Artifacts and Packages
Monitor Archive and Restoration Operations
Work with Cold Storage Using REST APIs
Set up Retention Policies Using a REST API
Archive Artifacts Using a REST API
Manage Archive Policies Using REST APIs
Search and Restore Archived Artifacts Using REST APIs
Monitor the Archive and Restore Processes using a REST API
Review Archive and Restore Logs
Archive Logs
Restore Logs
Cold Storage Limitations, Known Issues and Workarounds
JFrog Platform Navigation
Support Zone

Configure JFrog OIDC Integration with GitLab
Sample GitLab Workflow YAML

Back to home page